Shareware 1 2 the Maxx/sw_1.zip/sw_1/PROGRAM/AMISL083.ZIP/AMIS.ASM

Assembly Source File | 1992-05-02 | 19KB | 708 lines

;-----------------------------------------------------------------------
; Alternate Multiplex Interrup Specification Library
; AMIS.ASM    Public Domain 1992 Ralf Brown
;        You may do with this software whatever you want, but
;        common courtesy dictates that you not remove my name
;        from it.
;
; Version 0.83
; LastEdit: 5/2/92
;-----------------------------------------------------------------------

    INCLUDE AMIS.MAC

TSRcode@
EXTRN HOOKED_INT_LIST:BYTE
EXTRN MULTIPLEX_NUMBER:BYTE
EXTRN ALTMPX_SIGNATURE:BYTE
EXTRN ALTMPX$PSP:WORD
TSRcodeEnd@

IFNDEF __TINY__
EXTRN __psp:WORD
ENDIF

;-----------------------------------------------------------------------

_TEXT SEGMENT PUBLIC BYTE 'CODE'
    ASSUME    CS:_TEXT

;-----------------------------------------------------------------------

alloc_strat    dw 0
link_state    db 0    ; are UMBs part of memory chain?
install_flags    db 0    ; mpx_number must immediately follow
mpx_number    db 0    ; multiplex number to install on/when uninstalling

;-----------------------------------------------------------------------
; Terminate back to DOS.  Depending on where the resident code was moved,
; the program will be terminated either with a normal terminate call or
; with a terminate-and-stay-resident call.
;
public $go_TSR
$go_TSR proc DIST
    db    0BAh        ; MOV    DX,IMM16
resident_size    dw 0        ; number of paras to keep on going TSR
    db    0B8h        ; MOV    AX,IMM16
exit_code    db 0        ; exit_func must immediately follow
exit_func    db 4Ch        ; will change to 31h if we must go resident
    int    21h
$go_TSR endp

;-----------------------------------------------------------------------
; entry: AX = segment of TSR code within the currently executing transient
;        program (AX:ALTMPX_SIGNATURE is used)
; exit:     CF clear if not installed
;        AL = 00h if free multiplex number exists
;            AH = multiplex number to use
;           = 01h if all multiplex numbers are already in use
;            AH destroyed
;        CX destroyed
;     CF set if already installed
;        AL = FFh
;        AH = multiplex number being used
;        CX = version number of resident TSR
;
public check_if_installed
check_if_installed proc DIST
    ASSUME    DS:NOTHING,ES:NOTHING
    push    ds
    push    es
    push    si
    push    di
    push    dx
    push    bx
    mov    ds,ax
    ASSUME    DS:RESIDENT_CODE
    xor    ax,ax            ; AH=mpx #00h, AL=func 00h (instchk)
    mov    bx,0001h        ; BH=00h, BL=01h: all mpx numbers in use
chk_installed_loop:
    push    ax
    int    2Dh            ; check if INT 2D/AH=xx is in use
    cmp    al,0FFh            ; multiplex number in use?
    pop    ax
    je    chk_installed_inuse
    or    bl,bl            ; if BL=00h, we've already seen a free mpx
    je    chk_installed_next
    mov    bl,0
    mov    bh,ah
    jmp short chk_installed_next
chk_installed_inuse:
    mov    es,dx
    ASSUME    ES:NOTHING
    mov    si,offset RESIDENT_CODE:ALTMPX_SIGNATURE
    push    cx            ; remember version number
    mov    cx,16/2            ; length of signature string
    cld
    rep    cmpsw
    pop    cx            ; retrieve version
    stc                ; assume already installed
    jz    chk_installed_done    ;   and quit if it is
chk_installed_next:
    inc    ah
    jnz    chk_installed_loop
; not yet installed
    clc
    mov    ah,bh            ; AH <- multiplex number to use
    mov    al,bl            ; AL <- 'available' flag
chk_installed_done:
    pop    bx
    pop    dx
    pop    di
    pop    si
    pop    es
    pop    ds
    ASSUME    DS:NOTHING,ES:NOTHING
    ret
check_if_installed endp

;-----------------------------------------------------------------------
; entry: DS:SI -> hooked interrupt list
; exit:     AX, BX, CX, DX destroyed
;     CF set if unable to unhook all vectors
;     CF clear if successful
;
public unhook_interrupts
unhook_interrupts proc DIST
    push    es
    push    ds
    push    di
    push    si
    cld
chk_unhook_loop:
    lodsb
    mov    dx,[si]            ; get offset of interrupt handler
    inc    si            ;   and skip that field in the hook
    inc    si            ;   list
    cmp    al,2Dh
    je    all_unhookable
    mov    ah,35h
    int    21h            ; get interrupt vector
    mov    ax,es
    mov    cx,ds
    cmp    ax,cx            ; check segment agains of vectors
    jne    chk_isp_loop
    cmp    dx,bx            ; check offset of vector against ours
    je    chk_unhook_loop        ; this int is unhookable if same
chk_isp_loop:
    cmp    word ptr es:[bx],10EBh    ; handler starts with JMP SHORT $+12 ?
    jne    not_unhookable
    cmp    word ptr es:[bx+6],424Bh ; valid signature?
    jne    not_unhookable
    cmp    byte ptr es:[bx+9],0EBh ; hardware reset must also be JMP SHORT
    jne    not_unhookable
    cmp    cx,word ptr es:[bx+4]    ; check segment of next ptr against ours
    jne    chk_next_isp
    cmp    dx,word ptr es:[bx+2]    ; check offset of next ptr against ours
    je    chk_unhook_loop        ; this int is unhookable if same
chk_next_isp:
    les    bx,es:[bx+2]        ; advance to next ISP header
    jmp    chk_isp_loop        ;   and test it

not_unhookable:
    stc
unhook_ints_done:
    pop    di
    pop    si
    pop    ds
    pop    es
    ret

all_unhookable:
    pop    si            ; get back start of hook list
    push    si            ; and preserve SI for return
unhook_loop:
    lodsb
    mov    dx,[si]
    inc    si
    inc    si
    push    ds
    push    ax
    mov    ah,35h
    int    21h            ; get interrupt vector
    mov    ax,es
    mov    cx,ds
    cmp    ax,cx            ; check segments of vectors
    jne    isp_loop
    cmp    dx,bx            ; check offsets of vectors
    jne    isp_loop
    lds    dx,[bx+2]        ; get our old_int?? pointer
    pop    ax
    push    ax
    mov    ah,25h            ; set interrupt vector
    int    21h
    jmp short unhooked_interrupt
isp_next:
    les    bx,es:[bx+2]        ; advance to next ISP header
isp_loop:
;
; no need to check for a valid ISP header, as we already know all chains reach
; our header before non-ISP code
;
    cmp    cx,es:[bx+4]        ; check segment of 'previous' ptr
    jne    isp_next
    cmp    dx,es:[bx+2]        ; check offset of 'previous' ptr
    jne    isp_next
    xchg    bx,dx
    lds    bx,[bx+2]
    xchg    bx,dx            ; ES:BX -> previous ISP
                    ; DS:DX -> next ISP
    mov    es:[bx+2],dx        ; prev->next = curr->next
    mov    es:[bx+4],ds        ;    thus, we are now unhooked
unhooked_interrupt:
    pop    ax
    pop    ds
    cmp    al,2Dh
    jne    unhook_loop
    clc                ; indicate success
    jmp    unhook_ints_done
unhook_interrupts endp

;-----------------------------------------------------------------------
; Call the XMS driver to allocate an upper memory block
;
; entry: DX = number of paragraphs needed
; exit:     ZF set if successful
;         BX = segment address of UMB
;
alloc_UMB proc near
    mov    ah,10h
    ;; fall through to XMS ;;
alloc_UMB endp

;-----------------------------------------------------------------------
; Call the XMS driver
;
; entry: all registers as needed for XMS call
; exit:     registers as returned by XMS driver
;     ZF set if successful, ZF clear if failure
;
XMS proc near
    db    09Ah    ; FAR CALL
xms_entry dd    0    ; XMS driver's entry point
    cmp    ax,1
    ret
XMS endp

;-----------------------------------------------------------------------
; Determine entry point of XMS driver and initialize procedure XMS to call
; that entry point
;
; exit: CF set if no XMS driver or other failure
;    CF clear if initialization successful
;    AX,BX destroyed
;
get_XMS_entry proc near
    push    es
    mov    ax,352Fh
    int    21h            ; find out whether INT 2F is valid
    mov    ax,es
    or    ax,bx            ; don't try XMS if INT 2F is NULL
    jz    no_XMS_driver        ; (could be case under DOS 2.x)
    mov    ax,4300h        ; see if XMS is installed
    int    2Fh
    cmp    al,80h            ; did XMS respond?
    jnz    no_XMS_driver
    mov    ax,4310h        ; if XMS present, get its entry point
    int    2Fh
    mov    word ptr xms_entry,bx
    mov    word ptr xms_entry+2,es ; and store entry point for call
    pop    es
    clc
    ret
no_XMS_driver:
    pop    es
    stc
    ret
get_XMS_entry endp

;-----------------------------------------------------------------------
; Get an Upper Memory Block from the XMS driver; depending on the
; installation flags, this block will either be the first one available
; or the one closest in size to the requested amount
;
; entry: AX = number of paragraphs needed
; exit:     AX = segment of UMB or 0000h if unable to allocate one
;
allocate_UMB proc near
    mov    dx,ax            ; remember amount of memory to alloc
    call    get_XMS_entry
    jc    no_XMS_avail
    test    install_flags,BEST_FIT
    jnz    alloc_bestfit_UMB    ; DX = amount to request
alloc_XMS:
    call    alloc_UMB        ; ask XMS for the memory
    mov    ax,bx            ; (BX -> UMB if successful)
    je    allocate_UMB_done    ; if we got the mem, return now
no_XMS_avail:
    xor    ax,ax            ; return segment 0 if no UMB
allocate_UMB_done:
    ret
allocate_UMB endp

alloc_bestfit_UMB proc near
    push    si
    push    di
 @alloc_size = SI
 @umb_addr = DI
    mov    @alloc_size,dx        ; remember how much to request
    mov    dx,0FFFFh        ; try 1 meg
    call    alloc_UMB        ; ask XMS for the memory
    je    XMM_broken        ; if we got it, XMM seriously broken!
    cmp    dx,@alloc_size        ; DX = largest available
    jb    UMB_too_small        ; not enough high memory left
    call    alloc_UMB        ; allocate the largest UMB
    jne    XMM_broken        ; if we didn't get it, XMM broken
    mov    @umb_addr,bx        ; remember UMB address
    mov    dx,@alloc_size
    call    alloc_bestfit_UMB    ; recurse
    or    ax,ax
    jnz    got_block
    mov    ah,11h            ; deallocate UMB
    mov    dx,@umb_addr
    call    XMS
    mov    dx,@alloc_size
    call    alloc_UMB        ; ask XMS driver for the memory
    jne    UMB_too_small        ; did we get it?
    mov    ax,bx            ; BX = addr of UMB
    jmp short alloc_best_done

got_block:
    push    ax            ; remember address to return
    mov    ah,11h            ; deallocate UMB
    mov    dx,@umb_addr
    call    XMS
    pop    ax            ; retrieve return value
    jmp short alloc_best_done

XMM_broken:
UMB_too_small:
    xor    ax,ax            ; didn't get anything
alloc_best_done:
    pop    di
    pop    si
    ret
alloc_bestfit_UMB endp

;-----------------------------------------------------------------------
; entry: nothing
; exit:     CF set if not available, clear if available
;     AX,BX,CX,DX destroyed
;     if available, DOS5 UMBs have been linked into the memory chain
;
check_if_DOS5_UMBs proc near
    mov    ax,5800h
    int    21h            ; get current allocation strategy
    mov    alloc_strat,ax        ;   and remember it for later restore
    mov    ax,5802h        ; get current state of UMB linkage
    int    21h
    mov    link_state,al
    mov    ax,3000h        ; get DOS version
    int    21h
    cmp    al,5            ; DOS 5.0 or higher?
    jb    no_DOS5_UMBs
    cmp    al,10            ; but make sure not OS/2 penalty box
    jae    no_DOS5_UMBs
    mov    ax,2B01h
    mov    cx,4445h
    mov    dx,5351h
    int    21h            ; check if DESQview running
    cmp    al,0FFh            ; if yes, no UMB's to be allocated
    jne    no_DOS5_UMBs
    mov    ax,5803h
    mov    bx,1            ; try to link in UMBs
    int    21h
    mov    ax,5802h        ; get new link state
    int    21h
    cmp    al,1
    jne    no_DOS5_UMBs
    clc                ; yes, we have UMBs
    ret

no_DOS5_UMBs:
    stc
    ret
check_if_DOS5_UMBs endp

;-----------------------------------------------------------------------
;
; entry: BX = memory allocation strategy
; exit:     CF set on error
;     CF clear if successful
;        AX = segment of memory block
;
alloc_DOS_highmem proc near
    mov    ax,5801h        ; set allocation strategy
    int    21h
    mov    ah,48h            ; allocate memory
    mov    bx,resident_size    ;   this is how much we need
    int    21h            ; try to allocate the UMB
    pushf                ; remember whether we succeeded
    jc    no_highmem        ; did we succeed?
    push    ax            ; yes, so remember where to relocate
    dec    ax            ; address the MCB for our new memory
    mov    es,ax            ;   block
    inc    ax            ; back to relocation segment
    mov    word ptr es:[1],ax    ; make the memory block own itself
    mov    ah,51h            ; get current PSP
    int    21h
    dec    bx            ; back to MCB for main memory block
    push    ds
    mov    ds,bx            ; point at MCB
    ASSUME    DS:NOTHING
    push    si
    push    di
    mov    si,8
    mov    di,si
    cld
    movsw                ; copy the DOS 4.0+ program name into
    movsw                ;   the new memory block's MCB
    movsw
    movsw
    pop    di
    pop    si
    pop    ds
    ASSUME    DS:NOTHING
    pop    ax            ; retrieve relocation address
;---------------------------
; Reasons for mucking with the MCB:
;    DOS 5 will release any memory blocks owned by the program when
;    it exits without going TSR, even if the blocks are in high memory
;    and high memory has been disconnected from the memory chain.  So,
;    we need to change the owner field such that DOS thinks it belongs to
;    somebody else and doesn't release it when we exit.
;---------------------------
no_highmem:
    popf                ; get back whether we were successful
restore_link_state:
    pushf                ; store flags, especially CF
    push    ax
    mov    ax,5801h
    mov    bx,alloc_strat        ; restore allocation strategy
    int    21h
    mov    ax,5803h        ; and restore UMB link status
    mov    bh,0
    mov    bl,link_state
    int    21h
    pop    ax
    popf                ; get back flags
    ret
alloc_DOS_highmem endp

;-----------------------------------------------------------------------
; entry: AL = flags
;        bit 0 = use first-fit alloc, nonzero = use best-fit alloc
;        bit 1 = use UMB only, never conventional memory
;        bit 2 = use top of lower memory (at 640K)
;        bit 7 = patch resident portion's PSP return value
;     AH = multiplex number
;     BX = segment of resident code
;     CX = size of resident code in paragraphs
;     DX = additional paragraphs
; exit:     CF clear if successful
;         AX = segment at which TSR was installed
;     CF set on error
;
public $install_TSR
$install_TSR proc DIST
    push    es
    push    si
    push    di
    mov    word ptr install_flags,ax ; set both install_flags & mpx_number
    push    bx            ; remember segment of resident code
    push    cx            ; remember size of resident code
    mov    ax,cx
    add    ax,dx
    mov    resident_size,ax
 ;
 ; first, see if we can load into a DOS5 UMB (this is preferred because
 ; 386MAX will give us an XMS UMB even if DOS5 has grabbed them, but at
 ; a cost of an extra 80 bytes of overhead).
 ;
     test    install_flags,LOW_ONLY
    jnz    not_XMS
    call    check_if_DOS5_UMBs    ; check if UMBs avail, and link them in
    jc    not_dos5
    mov    bx,40h            ; alloc high memory only, first-fit
    test    install_flags,BEST_FIT
    jz    go_allocate_DOS_highmem
    inc    bx            ; BX <- 41h = alloc high only, best-fit
go_allocate_DOS_highmem:
    call    alloc_DOS_highmem
    jnc    relocate_TSR_code    ; if successful, go install
 ;
 ; if not DOS5, see if we can load into an XMS upper memory block
 ;
not_dos5:
    mov    ax,resident_size
    call    allocate_UMB        ; try to get AX paragraphs
    or    ax,ax            ; did we get a UMB?
    jnz    relocate_TSR_code    ; if yes, go install at segment AX

 ;
 ; if not XMS, see whether we are allowed to load into conventional memory;
 ; if yes, check whether we are supposed to load at the high or low end of
 ; conventional memory
 ;
not_XMS:
    test    install_flags,UMB_ONLY
    jnz    install_failure
install_low:
    test    install_flags,USE_TOPMEM
    jz    not_topmem
    mov    bx,2            ; last-fit in low memory
    call    alloc_DOS_highmem    ; try to allocate at top of memory
    jnc    relocate_TSR_code    ; and go install
install_failure:
    pop    cx            ; clean up stack
    pop    bx
    jmp    install_failed
 ;
 ; as a last resort, use our own PSP to store the code, and go resident
 ;
not_topmem:
    mov    ax,cs
    add    ax,4            ; copy to offset 40h in PSP
    push    ax            ; remember where we'll relocate
    add    resident_size,4
    mov    exit_func,31h        ; TSR rather than normal exit
    xor    ax,ax
IFDEF __TINY__
    xchg    ax,cs:[002Ch]        ; get and zero environment segment
ELSE
    mov    es,__psp
    xchg    ax,es:[002Ch]        ; get and zero environment segment
ENDIF
    mov    es,ax
    mov    ah,49h            ; since we will be going resident,
    int    21h            ;   discard our environment
    pop    ax            ; get back destination segment
 ;
 ; relocate TSR code into the PSP or UMB
 ; at this point, AX must be the segment at which to relocate
 ;
relocate_TSR_code:
    pop    cx            ; get back TSR code size in paragraphs
    pop    bx            ; get back TSR code segment
    push    ds
    mov    ds,bx
    ASSUME    DS:NOTHING
    mov    es,ax            ; ES -> resident_seg
    ASSUME    ES:NOTHING
    xor    si,si
    xor    di,di
    mov    ax,16            ; bytes per paragraph
    mul    cx            ; get size in bytes
    or    dx,dx
    jnz    install_failed_pop    ; can only handle 64K at this time
    mov    cx,ax            ; number of bytes to copy
    cld
    rep    movsb            ; copy the TSR's code
    mov    al,mpx_number        ; patch the multiplex number in the
    mov    es:[multiplex_number],al ;  resident code
    test    install_flags,PATCH_RESIDENT
    jz    install_no_patch
    mov    ax,es            ; AX <- resident_seg
    cmp    exit_func,4Ch
    je    install_patch
IFDEF __TINY__
    mov    ax,cs
ELSE
    pop    ds            ; restore DS
    mov    ax,__psp
    push    ds            ; need DS on stack
ENDIF
install_patch:
    mov    word ptr es:[ALTMPX$PSP],ax
install_no_patch:
    push    es            ; remember resident segment
    push    es
    pop    ds            ; DS -> resident_seg
    mov    si,offset RESIDENT_CODE:HOOKED_INT_LIST
hook_interrupts:
    lodsb                ; get interrupt number
    mov    ah,35h            ; get interrupt vector
    int    21h
    mov    dx,bx            ; ES:DX -> prev handler
    mov    bx,[si]            ; get offset of interrupt handler
    inc    si
    inc    si
    mov    [bx+2],dx        ; set 'previous' pointer in ISP header
    mov    [bx+4],es
    mov    dx,bx            ; DS:DX -> our handler
    mov    ah,25h            ; AL still interrupt number
    int    21h            ; hook the interrupt
    cmp    al,2Dh            ; INT 2Dh is last in hook list
    jne    hook_interrupts
    pop    ax            ; AX <- resident_seg
    pop    ds
;    clc                ; we were successful ;(CF already clear)
install_TSR_done:
    pop    di
    pop    si
    pop    es
    ret

install_failed_pop:
    pop    ds
install_failed:
    stc                ; signal installation failure
    jmp    install_TSR_done
$install_TSR endp

;-----------------------------------------------------------------------
; entry: AX = segment of TSR code within the calling executable
; exit:     CF clear if successful
;     CF set on error
;     AX,BX,CX,DX destroyed
;
public $uninstall_TSR
$uninstall_TSR proc DIST
    push    es
    call    check_if_installed
    jnc    not_installed
    ;
    ; TSR is installed, AH=multiplex number
    ;
    mov    mpx_number,ah
    ;
    ; first, see whether the TSR can uninstall itself
    ;
    mov    al,2
    mov    dx,cs            ; load return address for success
    mov    bx,offset _TEXT:uninstall_successful
    int    2Dh
    cmp    al,0FFh            ; successful?
    je    uninstall_successful
    cmp    al,02h            ; will uninstall itself
    je    uninstall_successful
    cmp    al,01h            ; unable to remove at this time?
    je    uninstall_failed
    cmp    al,05h            ; unknown return code?
    jae    uninstall_failed
    ;
    ; TSR said it is safe to uninstall, but not able to do so itself,
    ; so now we find out which interrupts it has hooked
    ;
    mov    es,bx            ; point ES at memory block to be freed
    ASSUME    ES:NOTHING
uninst_chk_int_loop:
    mov    ah,mpx_number
    mov    al,4
    mov    bl,0            ; start with INT 00h
    int    2Dh
    cmp    al,1            ; function unsupported or can't determine?
    jbe    uninstall_failed
    cmp    al,4
    je    go_uninstall

;    jmp short uninstall_failed    ; sorry, can't handle returns 02h/03h yet
uninstall_failed:
not_installed:
    pop    es            ; clean up stack
    stc                ; indicate error
    ret

go_uninstall:
    push    ds
    push    si
    mov    ds,dx            ; DS:SI -> hook list
    mov    si,bx
    call    unhook_interrupts
    pop    si
    pop    ds
    jc    uninstall_failed
    mov    ax,es            ; get segment of memory block
    cmp    ax,0B000h        ; regular DOS memblk if below video
    jae    uninstall_highmem
    mov    ah,49h            ; free memory block
    int    21h
uninstall_successful:
    pop    es            ; clean up stack
    clc                ; indicate success
    ret

uninstall_highmem:
    call    check_if_DOS5_UMBs    ; check if UMBs, and link them in
    jc    uninstall_XMS
    mov    ah,49h            ; free the memory block via DOS
    int    21h            ;   (ES already points at block)
    call    restore_link_state
    jmp    uninstall_successful

uninstall_XMS:
    call    get_XMS_entry
    jc    uninstall_failed    ; no XMS driver!?!?!
    mov    ah,11h            ; release UMB
    mov    dx,es            ; set DX to UMB segment
    call    XMS
    jne    uninstall_failed    ; we deallocation successful?
    jmp    uninstall_successful
$uninstall_TSR endp

;-----------------------------------------------------------------------

_TEXT ENDS
    END