Date: Sunday, 1 January 1989  11:43-MST
From: <MULTI%TRIUMFCL.BITNET@CORNELLC.CIT.CORNELL.EDU>
Re:   TSR program that "unhooks" itself, see Issues 49,57 of 1988 digest

Title   U
Page    80,132
BUFLEN  =64                             ; Length of command save
;DBG    =1                              ; Define for printout
GUARD   =0                              ; Length of guard band
INTDOS  =21h*4                          ; Address of DOS vector
PSPOFF  =5Ch                            ; PSP above here overlaid
RELOC   =100h-PSPOFF                    ; Distance code shuffled
;
 .SFCOND                                ; Suppress false conditionals
;
Code    Segment
        ORG     100h
Assume  cs:code,ds:code
start   label   byte
count:  jmp     u                       ; Command being recalled
punt:   db      0EAh                    ; Far jump to DOS
chain   dw      2 dup(?)                ;  ...int 21h entry
;
begin:  cmp     ah,0Ah                  ; Buffered keyboard input request?
        jne     punt                    ;  ...no, pass to DOS
        push    ax
        push    bx
        push    cx
        push    dx
        push    si
        push    di
        push    es
        push    ds
        pop     es
        mov     di,dx                   ; DS:DI --> user's buffer
        inc     di                      ; Skip maximum  byte count
        inc     di                      ; Skip returned byte count
        mov     bx,dx                   ; Load into index register
        cld                             ; Strings advance forwards
retry:  mov     byte ptr [bx]+1,0       ; Zero returned byte count
;
loop:   call    in                      ; Read char into AL reg
loop1:  cmp     al,0Dh                  ; Entry process char in AL reg
        je      done
        or      al,al                   ; Function key?
        je      f_key                   ;  ...begins with null
        cmp     al,"H"-64               ; Backspace
        je      erase
        cmp     al,"U"-64               ; ^U
        je      erall
        cmp     al,27                   ; Escape
        je      erall
        mov     dx,[bx]                 ; Get both byte counts
        cmp     dh,dl                   ;  ...full if equal
        je      bell                    ;  ...ignore,bell if so
        stosb                           ; Save character
        call    echo                    ;  ...echo it
        cmp     byte ptr [di]-1,"C"-64  ; ^C character
        je      break                   ;  ...causes interrupt
        inc     byte ptr [bx]+1         ; End of checking, accept char.
        jmp     loop                    ;  ...back for more
;
f_key:  call    in                      ; AL contains 2nd char
        or      al,al                   ; Zero is break
        je      break
        cmp     al,61                   ; F3 = Function Recall
        je      recal
        cmp     al,72                   ; Cursor up,, same thing
        je      recal
        cmp     al,65                   ; F7 = Function Recall Backwards
        je      rbc
        cmp     al,80                   ; Cursor Down, same thing
        je      rbc
        cmp     al,64                   ; F6 = Control-Z
        je      ctrl_z
        jmp     loop                    ; Ignore the remainder
;
ctrl_z: mov     al,"Z"-64               ; F6 is Control-Z
        jmp     loop1                   ;  ...pretend from keyboard
;
recal:  jmp     recall
rbc:    jmp     rbck
;
break:  int     23h                     ; Control_Break
        call    crlf                    ;  ...as per documentation
        jnc     retry                   ;  ...carry clear, retry
        mov     ax,4C00h                ; Else do a kosher terminate
        int     21h                     ;  ...do not know his PSP
;
done:   stosb                           ; Success, save 0Dh terminator
        call    store                   ; Store the command
        pop     es                      ; Done, restore reg. and exit
        pop     di
        pop     si
        pop     dx
        pop     cx
        pop     bx
        pop     ax
        iret
;
erase:  call    delete
        jmp     loop
;
erall:  call    delete
        cmp     Byte ptr [bx]+1,0
        jne     erall
        jmp     loop
;
bell:   mov     al,7
        call    out
        jmp     loop
;
recall: call    delete                  ; Attempt to delete char.
        cmp     Byte ptr [bx+1],0       ;  ...any left to delete
        jne     recall                  ;  ...yes, loop around
;
        push    ds                      ; Save user's DS
        push    bx                      ;  ...and BX reg
        push    cs                      ; Make DS the same
        pop     ds                      ;  ...as code seg
;
        xor     bx,bx                   ; Go to start of buffer
        mov     dx,word ptr count-RELOC ; DX is count of comands
        inc     word ptr count-RELOC    ; One more in stack
;
rec0:   dec     dx                      ; This command
        je      extrct                  ;  ...yes
;
        mov     cl,[save-RELOC+bx]      ; Get saved byte count
        mov     ch,0                    ;  ...make word
        jcxz    rec90                   ; End of commands
        inc     cx                      ;  ...skip past char count
        add     bx,cx                   ;  ...and string
        cmp     bx,BUFLEN               ; Buffer overflowed
        jae     rec90
        jmp     rec0                    ;  ...and continue

rec90:  xor     bx,bx                   ; Back to start of buffer
        mov     word ptr count-RELOC,2  ; Say one command there
extrct: mov     cl,[save-RELOC+bx]      ;  ...get char count
        mov     ch,0                    ;  ...be safe
        lea     si,[save+1-RELOC+bx]    ; ds:SI --> input buffer
        inc     bx                      ; Add in character counter
        add     bx,cx                   ; Length of line
        cmp     bx,BUFLEN               ;  ...will it fit?
        jae     rec90                   ;  ...no, so restart
        pop     bx
        cmp     cl,es:[bx]              ; Compare with new buffer
        jbe     fit                     ;  ...will fit
        mov     cl,es:[bx]              ;  ...copy what will fit
fit:    mov     es:[bx]+1,cl            ; Get saved byte count
        jcxz    nul                     ;  ...all done
        lea     di,[bx]+2               ; ES:DI --> user  buffer
;
l:      lodsb                           ; Load AL from input  buffer
        stosb                           ; Dump AL into output buffer
        call    echo                    ; Echo AL on   print  screen
        loop    l                       ;  ...loop until CX=0
;
nil:    pop     ds                      ; Restore user's DS
        jmp     loop                    ;  ...back for more
;
nul:    cmp     save-RELOC,0            ; Buffer really empty?
        je      nil                     ;  ...yes, nothing to recall
        push    bx                      ; Else save BX
        jmp     rec90                   ;  ...EOB, go back to start
;
rbck:   sub     word ptr cs:count-RELOC,2; Back two commands
        jle     toofar
bckr:   jmp     recall                  ;  ...and recall
toofar: push    ds                      ; Must scan for the
        push    bx                      ;  ...end of buffer
        push    cs                      ; Make DS the same
        pop     ds                      ;  ...as code seg.
        xor     bx,bx                   ; Beginning of buffer
        mov     word ptr count-RELOC,0  ; Start at command 0
bck1:   mov     cl,[save-RELOC+bx]      ; Get saved byte count
        mov     ch,0                    ;  ...be safe
        jcxz    bck90                   ; Not very nice, null string
        inc     cx                      ; Include char. count
        add     bx,cx                   ; Now point at next string
        cmp     bx,BUFLEN               ; Buffer overflowed
        jae     bck90                   ; Not very nice
        inc     word ptr count-RELOC    ; Another kosher stored command
        jmp     bck1
;
bck90:  cmp     word ptr count-RELOC,0  ; Too small?
        ja      bck91                   ;  ...no
        mov     word ptr count-RELOC,1  ; Must have one command
bck91:  pop     bx                      ; Got our answer
        pop     ds                      ;  ...restore
        jmp     bckr                    ; Go to find command routine
;
delete: cmp     Byte ptr [bx]+1,0       ; Anything to delete
        je      delret                  ;  ...no, then nop
        dec     di                      ; Back up pointer
        mov     al,[di]                 ;  ...AL has char
        dec     Byte ptr [bx]+1         ; One less in buffer
        mov     cx,1                    ; Assume takes one print pos.
        cmp     al," "                  ;  ...space and above OK
        jae     norm                    ;  ...blank out one position
        inc     cx                      ; Control char blank out two
;
norm:   mov     al,"H"-64               ; Backspace over char.
        call    out                     ;  ...print backspace
        mov     al," "                  ; Destructive overprint
        call    out                     ;  ...print space
        mov     al,"H"-64               ; Backspace to one before
        call    out                     ;  ...print backspace
        loop    norm                    ; Destroy one or two char.
delret: ret                             ;  ...all done
;
in:     mov     ah,7                    ; Read/no echo
        int     21h                     ; AL contains char
        ret                             ;  ...back to user
;
out:    push    dx                      ; Save register
        mov     dl,al                   ; Get character to print
        mov     ah,2                    ;  ...on print screen
        int     21h                     ;  ...do DOS call supposed
        pop     dx                      ;  ...restore reg.
        ret                             ;  ...to check for break
;
echo:   cmp     al,32                   ; Char in AL destroyed
        jae     nocntl                  ;  ...is space or above
        push    ax                      ; Else save a copy
        mov     al,"^"                  ;  ...print ^ arrow
        call    out                     ;  ...this way
        pop     ax                      ; Restore char in AL
        add     al,"A"-1                ;  ...map control to letter
nocntl: call    out                     ; Print the character
        ret                             ;  ...back to DOS
;

store:  mov     cl,[bx]+1               ; Char. count for new command
        mov     ch,0                    ;  ...null hi order
        jcxz    null                    ;  ...no command
        inc     cx                      ;  ...include Count in string
        cmp     cx,BUFLEN               ; String too long
        ja      null                    ;  ...yes, don't save
        push    cx                      ;  ...save a copy
        neg     cx                      ;  ...negate length
        lea     di,save+BUFLEN-RELOC-1  ; Source for shuffle
        lea     si,save+BUFLEN-RELOC-1  ; Target for shuffle
        add     si,cx                   ;  ...back up source
        add     cx,BUFLEN               ;  ...size of buffer to shuffle
        js      null                    ;  ...too big
        push    ds                      ; Save old DS segment
        push    cs
        pop     ds                      ; DS = CS
        push    cs
        pop     es                      ; ES = CS
        std                             ;  ...shuffle backwards
;
        rep     movsb                   ;  ...push old commands
        mov     word ptr count-RELOC,1  ;  ...reset buffer pointer
;
        pop     ds                      ; Restore data segment
        pop     cx                      ; Restore line length
        lea     si,[bx]+1               ; Get address of counted line
        lea     di,save-RELOC           ; ES:DI --> Save buffer
        cld                             ;  ...save forwards
        rep     movsb                   ;  ...save into local buffer
Ifdef   DEB
        call    debug                   ; *** DEBUG ***
endif
null:   ret                             ;  ...back to caller
;
crlf:   push    ax
        mov     al,13
        call    out
        mov     al,10
        call    out
        pop     ax
        ret
;
Ifdef   DEB
number: push    ax
        push    cx
        mov     cx,4
num:    rol     bp,1
        rol     bp,1
        rol     bp,1
        rol     bp,1
        mov     ax,bp
        and     ax,0Fh
        add     ax,"0"
        cmp     ax,"9"
        jbe     num1
        add     ax,"A"-"9"-1
num1:   call    out
        loop    num
        pop     cx
        pop     ax
        ret
;
debug:  push    ax
        push    bx
        push    ds
        push    cs
        pop     ds
        xor     bx,bx
deb0:   test    bx,63
        jne     deb1
        call    crlf
        mov     bp,cs
        call    number
        mov     al,":"
        call    out
        lea     bp,[save-RELOC+bx]
        call    number
        mov     al," "
        call    out
deb1:   mov     al,[save-RELOC+bx]
        inc     bx
        cmp     al," "
        jae     deb2
        mov     al,"."
deb2:   call    out
        cmp     bx,BUFLEN+GUARD         ; *** DEBUG ***
        jb      deb0
        pop     ds
        pop     bx
        pop     ax
        ret
Endif
;
impure  label   byte                    ; End of area to check for install
;
save    db      ?                       ; Token null for buffer
;
quit    label   byte                    ; End of permanent region
;
u:      xor     dx,dx                   ; Get vector segment
        mov     es,dx                   ;  ...and load into ES
        lds     si,dword ptr es:INTDOS  ; DS:SI --> DOS interrupt routine
        mov     cx,offset impure-begin  ;  ...this is pure code to compare
        push    cs                      ; Save code      segment
        pop     es                      ; ES same as code seg.
        lea     di,begin                ; ES:DI --> our interrupt service
        rep     cmpsb                   ; Are they the same?
        push    cs                      ; Set data segment same as
        pop     ds                      ; the code segment
        jz      remove                  ;  ...code compares, remove
;
        lea     si,start                ; DS:SI --> Code segment
        mov     di,PSPOFF               ; ES:DI --> Where relocates to
        mov     cx,offset quit-start    ; CX = bytes to relocate
        rep     movsb                   ;  ...shuffle section down
;
        mov     ds,dx                   ; Reload vector segment
        mov     si,INTDOS               ; DS:SI --> DOS  vector
        lea     di,chain-RELOC          ; ES:DI --> JMPF address
        movsw                           ; Move the offset
        movsw                           ; Move the segment
        push    cs                      ; Equivalence code and
        pop     ds                      ;  ...data segments
        mov     es,dx                   ; ES:DI --> DOS  vector
        mov     di,INTDOS
        lea     ax,begin-RELOC          ; AX is entry offset
        stosw                           ;  ...store as DOS vector
        mov     ax,cs                   ; CS is entry segment
        stosw                           ;  ...store as DOS vector
;
        mov     word ptr count-RELOC,1  ;  ...reset count
;
        lea     dx,msg1                 ; Say editor installed
        mov     ah,9h                   ;  ...print string
        int     21h                     ;  ...like so
;
        push    ds:2Ch                  ; Get environ. segment
        pop     es                      ;  ...into ES register
        mov     ah,49h                  ;  ...then free
        int     21h                     ;  ...the memory
;
        lea     dx,save+BUFLEN-RELOC    ; Last address to save
        int     27h                     ;  ...terminate, stay resident
;
remove: lea     dx,msg2                 ; Code already was installed
        mov     ah,9h                   ;  ...print string
        int     21h                     ;  ...is function
        xor     dx,dx                   ; Point to vector area
        mov     es,dx                   ;  ...to restore DOS
        lds     si,dword ptr es:INTDOS  ; Get saved dos interrupt
        mov     di,INTDOS+4             ; Where to restore old DOS entry
        std                             ;  ...copy backwards
        cmpsw                           ; Backspace SI and DI
        movsw                           ;  ...restore segment
        movsw                           ;  ...restore offset
        mov     bx,ds                   ; Get PSP of stored program
        dec     bx                      ; BX --> storage block
        mov     ds,bx                   ; DS --> storage block
        mov     word ptr ds:1,0         ; This deletes the PSP
        ret                             ;  ...back to caller
;
msg1:   db      "[Editor Installed]$"   ; Hooked to DOS, resident
msg2:   db      "[Editor Removed]$"     ; Unhooked, gone from memory
;
code    ends
;
End     count
