Want to protect your cyber security and still get fast solutions? Ask a secure question today.Go Premium

x
?
Solved

--Change an Interrupt Vector--

Posted on 2003-10-24
7
Medium Priority
?
2,145 Views
Last Modified: 2010-08-05
Hi!

1- How To Change An Interrupt Vector?(Example: Change INT 10,04 Vector To My Routine)
2- If I Change an Interrupt Vector, Changing Will Remain On The BIOS?


Please Give Me an Example For Q-1.
I'm Using Tasm.

Bye
Programmer-x
0
Comment
Question by:Hamidreza Vakilian
  • 3
5 Comments
 
LVL 2

Expert Comment

by:MrT-RSI
ID: 9615183
The interrupt table starts at 0000:0000. It consists of 265 dword dpointers (interrupt 0..255). Haven't ever tried this, but try to change these values.

If you only want to tackle service #4 you have to svae the original pointer. When your interrupt handler gets called you check the requested service, and if not #4 you call the original handler.

Good luck,

- Rob.
0
 
LVL 15

Author Comment

by:Hamidreza Vakilian
ID: 9620425
Hi MrT-RSI!

Please Give me An Program That Changes INT 13,02 Vector To Your ISR.

Bye
Programmer-x
0
 
LVL 19

Expert Comment

by:BrianGEFF719
ID: 9638996
There is a lot of TSR examples you can find online, For TASM look for TSRBones which is a very good TSR example.
0
 
LVL 19

Expert Comment

by:BrianGEFF719
ID: 9639003
u want to intercept drive reads????
0
 
LVL 19

Accepted Solution

by:
BrianGEFF719 earned 200 total points
ID: 9639051
Here is TSR Bones, it should help you design a TSR.


;************************
PAGE 55,132             ;Format .LST listing at 55 lines by 132 columns.
TITLE TSRBONES Version 0.1 Jan 20 91 Robert Curtis Davis
SUBTTL Introduction
;**************************************************************************
;
;       TSRBONES.ASM     Version 0.1     Jan 20 91
;       A part of the TBONES software package.
;
;       Copyright (C) 1990, 1991 by Robert Curtis Davis,
;      All Rights Reserved.
;
;      DESCRIPTION:
;      ASM Program template for Terminate-and-Stay-Resident (TSR) programs
;            that are activated by a specified HotKey WHEN DOS IS NOT
;               BUSY (the InDOS Flag AND the DOS Critical Error Flag are zero)
;               flag), OR WHEN DOS IS AT "BUSY IDLE" (when INT28h is called),
;               AND WHEN NO HARDWARE INTERRUPT IRQ0-IRQ7 IS BEING HANDLED.
;               This avoids problems of interfering with hardware interrupt
;               handling and with DOS non-reentrancy; and allows DOS function
;               calls above 0Ch to be used in the TSR routine. The TSR's code
;               prevents multiple installations. Also checks DOS version and
;               requires DOS Version 2 or later before installation is
;               permitted.
;
;      PURPOSE:
;      Provides a skeletal framework program as a starting point in the
;       design of your own HotKey TSRs which use DOS function calls, and
;       for which a single installation is desired.
;
;                   E-mail address:
;                    Internet: sonny@trantor.harris-atd.com
;
;                  US Mail address:
;                                   430 Bahama Drive
;                                   Indialantic, FL 32903
;
;**************************************************************************
;
; Special thanks to Roy Silvernail, whose persistent hacking (in the best
; sense of that word) and E-mail exchanges over the holiday season in
; December 1990, rooted out TBONES incompatibilities with Borland's TASM v.1.0.
;
;**************************************************************************
;
; Special thanks to Anto Prijosoesilo and Richard Brittain for E-mail
; exchanges which helped solve detailed problems with the implementation of
; the "Pseudo-Environment" idea.
;
;**************************************************************************
;
; Special thanks to David Kirschbaum, whose Toad Hall Tweaks significantly
; improved an early version of the TBONES Assembly Language code:
;
;v0.01      Toad Hall Tweak, 25 Nov 90
;**************************************************************************
SUBTTL Code Segment
PAGE
;**************************************************************************
;
CodeSeg            segment
            assume cs:CodeSeg,ds:CodeSeg
BeginDump      EQU      $            ;Roy Silvernail - Keep TASM 1.0 happy
                              ;when computing # resident paragraphs.
;
            org      2CH            ;v0.01 ORG in PSP to pick up the
envseg            label      word            ;v0.01 Environment Segment.
;
            org      100h            ;ORG for all COM programs.
;
Entry            PROC      NEAR            ;v0.01
            jmp      TSRinit            ;Jump over resident portion and
                              ;initialize things and make code
                              ;between Entry: and TSRinit: resident.
;
; Old Interrupt Vectors are stored here during TSR initialization:
oldint09        dd      ?               ;Keyboard Hardware Interrupt.
oldint13        dd      ?               ;Disk BIOS Interrupt.
oldint16        dd      ?               ;Keyboard BIOS Interrupt.
oldint28        dd      ?               ;DOS Idle Interrupt.
;
; For this HotKey TSR Template, specify Keyboard Interrupt 09h as the Hook:
HOOK09            equ      09h                  ;Hooked Interrupt 09h.
; Int 13h is used to set a flag to prevent TSR trigger while disk active:
HOOK13          equ     13h                     ;Hooked Interrupt 13h.
; Int 16h is hooked solely to provide way to check for prior TSR installation.
HOOK16            equ      16h                  ;Hooked Interrupt 16h.
; We also have to hook Interrupt 28h to check for "DOS idle":
HOOK28            equ      28h                  ;Hooked Interrupt 28h.
;
bellgate      db      0      ;Gate closed (=1) when in Bell routine.
                        ;Gate open (=0) when not in Bell routine.
; Below:
; EQUates related to the Intel 8259A Programmable Interrupt Controller (PIC)
;      chip. Hardware Interrupts IRQ0 through IRQ7 are controlled by the PIC.
;
;      To really understand the nitty-gritty details of this stuff,
;      you have to study the Intel Specification data for the 8259A PIC chip.
;      These EQUates are used in this TSR to examine the PIC chip's In Service
;      Register (ISR) to be sure that the TSR is not interrupting one of
;      the hardware interrupt service routines. The reason for not wanting to
;      interrupt these hardware interrupt service routines is that they are
;      often time-critical and can be compromised by intruding on them with
;      our TSR (for example, a hardware COM port interrupt-driven comm
;      program might lose bytes on a modem transfer if we bull our way in and
;      steal the CPU away from the comm program's service routine):
PICPORT            EQU      20h            ;I/O Port for the 8259A PIC chip.
ISRREQ            EQU      00001011B      ;This is a byte defining the
                              ;Operation Control Word 3 (OCW3) to
                              ;output on port 20h to make the PIC
                              ;chip's In Service Register available
                              ;for reading by the CPU on the
                              ;next IN 20h command.
;
; EQUs defining Key Flag weights in the Key Flag Byte:
RSHIFT            equ      00000001B            ;Right Shift Key Flag weight.
LSHIFT            equ      00000010B            ;Left Shift  Key Flag weight.
CTRL            equ      00000100B            ;Ctrl        Key Flag weight.
ALT            equ      00001000B            ;Alt         Key Flag weight.
;SCROLL          equ     00010000B               ;Scroll Lock Key Flag weight.
;NUM             equ     00100000B               ;Num Lock    Key Flag weight.
;CAPS            equ     01000000B               ;Caps Lock   Key Flag weight.
INSRT            equ      10000000B            ;Ins         Key Flag weight.
;
LockKeyMask     equ     10001111B               ;For masking out Scroll, Caps,
                                                ;and Num Lock bits in KeyFlags.
;
; Pointer to "DOS busy" (InDOS) flag (loaded during TSR initialization):
indosptr      dd      ?
;
; Pointer to "Critical Error" (CritErr) flag (loaded at TSR initialization):
criterrptr      dd      ?
;
; Pointer to "Print Screen" busy (PrtScrn) flag
prtscrn         dd      00500000h
;
; hotkeyflag used to signal HotKey pressed to "DOS idle" Interrupt 28h:
hotkeyflag      db      0       ;hotkeyflag initially zero.
;
; diskflag used to prevent TSR trigger during time-critical Disk operations:
diskflag        db      0       ;diskflag initially zero.
;*************************************************************************
;      Your HotKey is specified here:
;       (This sample HotKey is set for Ctrl-Alt-B)
;
; Specify TSR's HotKey Shift Keys:
KEYFLAGBYTE     equ     CTRL+ALT                ;HotKey Flags
;
; Specify TSR's HotKey Scan Code:
HOTKEY          equ     30h                     ;'B' (for Bones) key
;
;*************************************************************************
; Specify TSR's signature words:
TSRsigA         equ     'TS'            ;'TSRBONES' Signature
TSRsigB         equ     'RB'
TSRsigC         equ     'ON'
TSRsigD         equ     'ES'
;*************************************************************************
Entry      ENDP            ;v0.01
;
;*************************************************************************
SUBTTL User-supplied TSR Routine
PAGE
;*************************************************************************
ROUTINE         PROC    NEAR
;*************************************************************************
;      Code for your HotKey-triggered TSR routine  GOES HERE:
;      ( Here, a dummy routine has been placed which simply rings the
;        terminal Bell whenever the TSR is triggered. )
;
;      Announce this dummy TSR's trigger by a Bell signal:
;
Enter:
                mov     al,07h          ;al = ASCII Bell.
                mov     bh,0            ;Video page.
                mov     cx,1            ;No. of bytes to write.
                mov     ah,0Eh          ;BIOS Int10,OEh=TTY Screen.
                Int     10h             ;Write ASCII Bell to screen.
;
Exit:
                ret                     ;Return from TSR routine.
;
ROUTINE         endp
;
;      End of your HotKeyed TSR routine.
;***************************************************************************
SUBTTL Hooked Interrupts
PAGE
;***************************************************************************
;
NewInt09      PROC      FAR            ;v0.01
;
; The following three instructions often are said to "simulate an interrupt"
; that calls the PRIOR interrupt handler routine and then the prior interrupt
; handler's IRET instruction pops the flags and returns here to the point
; after the following CALL instruction.
;    The reason for "simulating the interrupt" here is to give prior (and
; presumably more time-critical) handlers a shot at processing this interrupt
; before we process with this TSR's code.
;
            pushf                  ;Push flags as a true interrupt would.
                cli                     ;Be sure interrupts are disabled.
            call      CS:oldint09      ;Call FAR PTR address of old interrupt
;                              ;     handler routine.
;
;
                push    ax      ;Prepare to check for Hotkey.
                push    bx      ;Save all registers (DS is already pushed).
                push    cx
                push    dx
                push    si
                push    di
                push    bp
                push    ds
                push    es
;
                push    CS              ;Set up data segment
                pop     DS              ;register to point to code segment.
;
                ASSUME  DS:CodeSeg      ;v0.01
;
;       Determine if the current Keyboard Interrupt (Int09h) occurred
;       because this TSR's HotKey was pressed:
                in      al,60h          ;Get current Key Scan Code.
                cmp     al,HOTKEY       ;Is it HotKey's Scan Code?
                jne     Exit09          ;Exit if not.
                mov     ah,02h          ;Int16h,Fcn02h:GetKEYFLAGBYTE.
                Int     16h             ;Return Key Flag Byte in al.
                and     al,LockKeyMask  ;Mask out Num, Caps, Scroll Lock bits.
                cmp     al,KEYFLAGBYTE  ;Are the HotKey Flags active ?
                jne     Exit09          ;Exit if not.
;
;       At this point, Hotkey is known to have been pressed. First, purge
;       the DOS Keyboard type-ahead buffer of the hot key(s) so they won't
;       be passed on to DOS:
;
ClrKbdBuf:      ;Clear Keyboard buffer:
                mov     ah,01h          ;Get Keyboard buffer status
                int     16h             ;via BIOS Interrupt 16h.
                jz      BufClr          ;Jump if buffer empty.
                mov     ah,00h          ;Get key from buffer (to purge it)
                int     16h             ;via BIOS Interrupt 16h.
                jmp     ClrKbdBuf       ;Loop back to purge another key.
BufClr:
;
; We shall allow other interrupts to occur during our TSR ROUTINE.
; If we didn't allow other interrupts (through the STI instruction),
; we could lock out time-critical interrupts from access to the CPU during
; our TSR routine. However, by allowing interrupts during our routine, we
; have an increased responsibility to make sure critical portions of our
; own code is not re-entered. (The "bellgate" stuff below is an example
; of a measure necessary to keep us from re-entering our own TSR's code).
; What we really want to do by allowing interrupts is to make the CPU avail-
; able to OTHER critical interrupt service routines WITHOUT swarming all over
; ourselves through multiple detections of our own HotKey.
;               This "gate" technique is a good one to keep in
;               mind whenever you have a code region in an interrupt handler
;               that needs to be protected from re-entry:
;
                cmp     bellgate,0      ;Is it clear to re-enter Hotkey code?
                jne     BusyExit09      ;Exit if not,
                mov     bellgate,1      ;Else, close gate and proceed.
;
                CLI                     ;DISABLE INTERRUPTS
;       Now we will check to be sure that no time-critical hardware interrupt
;       handling is underway. We do this by querying the Intel 8259A Program-
;       mable Interrupt Controller (PIC) chip's In Service Register (ISR) and
;      testing it to see that it is zero (i.e., nothing being serviced).
;
HotKeyPressed:
                mov     al,ISRREQ       ;al=PIC's OCW3 to ask for ISR Register.
            out      PICPORT,al      ;Tell PIC to get ISR ready for reading.
            jmp      Dally            ;Give PIC time to make ISR available.
Dally:            in      al,PICPORT      ;Fetch the ISR Register from PIC.
                or      al,al           ;Activate processor flags.
                jnz     SetFlag         ;If al not zero, go set flag.
;
;       At this point, HotKey is known to be pressed AND NO hardware interrupt
;      is being serviced. BUT is InDOS flag zero, indicating that DOS is
;      not busy and therefore can safely be entered? This will now be
;      checked:
;
HotKeyNoHWI:
            les      bx,indosptr      ;es:bx = pointer to InDOS flag
            mov      al,es:[bx]      ;al = InDOS flag.
                or      al,al           ;Activate processor flags.
                jnz     SetFlag         ;Jump if InDOS not zero.
;
;       Include a check on Critical Error flag. Don't trigger the TSR if
;       DOS is in the middle of handling a Critical Error:
;
                les     bx,criterrptr   ;es:bx = pointer to CritErr flag.
                mov     al,es:[bx]      ;al = CritErr flag.
;
;       Also, don't trigger the TSR if time-critical Disk access is underway:
;               Normally, this Disk check would not be necessary since the
;               InDOS flag would not be clear during Disk accesses, BUT some
;               software will bypass DOS and go directly to the BIOS Int13
;               Interrupt for Disk access. Therefore, to be safe, we HAVE to
;               be sure Int13 has not been entered and is not in the process
;               of performing time-critical Disk stuff when we hit the TSR
;               HotKey. Many TSRs don't even check this. They just depend
;               upon users not to hit the HotKey during Disk access. That seems
;               terribly risky to me:
;
                or      al,diskflag     ;al = CritErr | diskflag
                                        ; (| => Logical OR).
                jnz     Exit09          ;If al not zero, try again later.
;
;       Also, don't trigger the TSR if a PrtScrn is in progress:
;       (Is this really necessary? I don't think TSR will trigger during PrtSc)
                les     bx,prtscrn      ;ES:bx = pointer to PrtScrn busy flag.
                cmp     BYTE PTR es:[bx],1      ;Is PrtScrn in progress?
                je      Exit09          ;If so, try again later.
;
                STI                     ;Allow other interrupts in our TSR.
;
                call    ROUTINE         ;All is clear!, so call routine.
                mov     hotkeyflag,0    ;Be sure HotKey flag is reset.
                jmp     SHORT Exit09    ;Exit after TSR routine.
;
SetFlag:
                mov     hotkeyflag,1    ;Set HotKey Flag for use by Int28h.
;
Exit09:
                mov     CS:bellgate,0   ;Open gate allowing new HotKey detect.
BusyExit09:
                pop     es              ;Restore all registers
                pop     ds
                ASSUME  DS:NOTHING      ;v0.01
                pop     bp
            pop      di
            pop      si
            pop      dx
            pop      cx
            pop      bx
            pop      ax
;
;
;      Return from this TSR's Keyboard Interrupt 09h handler routine:
            iret
;
NewInt09      ENDP                  ;v0.01
;
;*************************************************************************
PAGE
;*************************************************************************
NewInt13        PROC    FAR             ;We hook Int13h only for purpose
                                        ;of setting a flag to prevent our
                                        ;TSR from triggering during time-
                                        ;critical Disk accesses.
                mov     CS:diskflag,1   ;Set flag to show Disk access.
;
                pushf                   ;Invoke prior Int13 handler
                cli                     ;(be sure interrupts disabled)
                call    CS:oldint13     ;by simulating an interrupt.
;
                mov     CS:diskflag,0   ;Clear flag to show Disk finished.
;
; The following RET 2 bumps the SP register up by 2 bytes to effectively
;        take the flags off the stack (where they were put by the invoking
;        INT 13h) WITHOUT popping them off and ruining the meaningful flags
;        left in the Flags register by the original DOS INT13 handler (the
;        DOS INT13 handler also returns via a RET 2 to keep from ruining the
;        Flags that the handler has painstakingly prepared for communicating
;        back to the calling program). The effect on the stack pointer, SP, is
;        exactly the same as with the more usual IRET. It is just that the Flags
;        in the Flag register are preserved at the values the handler placed
;        and wanted there.
;
                RET     2               ;Return from interrupt while
                                        ;preserving flags.
;
NewInt13        ENDP
;*************************************************************************
PAGE
;*************************************************************************
NewInt16      PROC      FAR            ;v0.01
;
                push    ds              ;Entry for New Int. Handler.
;                                       ;Save required registers.
;
                push    CS              ;Set data seg   v0.01
                pop     DS              ;to our CodeSeg v0.01
            ASSUME      DS:CodeSeg      ;v0.01
;
; This next portion of code provides back to the non-resident
; TSR installation code a check on whether the TSR has already been installed.
; It does this through the following technique:
;        Check to see if the ax, bx, cx, dx registers are loaded with this
;      TSR's signature words. Since all TSR ax signature words are chosen
;      so as NOT to match any allowed DOS Int16h Function in ah, ALL
;      standard DOS Int16h calls will exit from this sequence of compares
;      at the first JNE instruction below and will ultimately be processed
;      by the standard DOS Int16h handler.
;       The ONLY place where all the registers are loaded with THIS TSR's
;      signature words and then Int16h called is IN THE INITIALIZATION CODE
;      AT THE END OF THIS TSR. Given that all the signature words are matched
;      in the four comparisons below, we need to signal back to the
;      invoking TSR initialization code by setting the data registers to
;      values that NEVER would be returned by the standard DOS Int16h handler,
;      and that therefore could ONLY have come from this previously-installed
;      TSR's Int16h handler code. The TSR installation code will then take
;      the return of these unique register values as the indication that
;      this TSR has already been installed.
;
            cmp      ax,TSRsigA      ;Is ax = TSR signature word A?
            jne      Exit16            ;No, let regular Int16 handle this.
            cmp      bx,TSRsigB      ;Is bx = TSR signature word B?
            jne      Exit16            ;No, let regular Int16 handle this.
            cmp      cx,TSRsigC      ;Is cx = TSR signature word C?
            jne      Exit16            ;No, let regular Int16 handle this.
            cmp      dx,TSRsigD      ;Is dx = TSR signature word D?
            jne      Exit16            ;No, let regular Int16 handle this.
;
;       The ONLY way you ever get to here is by having called Int16h with the
;      ax, bx, cx, dx registers loaded with this TSR's signature words. This
;      only occurs in the TSR initialization routine. Therefore, set the
;       registers to return values that a DOS Int16h never would, and then
;       return from this interrupt back to the TSR initialization routine.
;
                xchg    bx,cx   ;Exchange regs. (DOS Int16h wouldn't do this)
            xchg      ax,dx      ;   "         "        "
;
                pop     ds      ;Restore regs.
                iret            ;Return from Int to TSR Initialize routine.
;
Exit16:
                pop     ds                      ;Restore all registers
            ASSUME      DS:NOTHING      ;v0.01
;
;       Chain to prior Interrupt 16h handler routine:
                jmp     CS:oldint16
;
NewInt16        ENDP            ;v0.01

;*************************************************************************
PAGE
;*************************************************************************
NewInt28      PROC      FAR            ;v0.01
;
                pushf                   ;Call prior handler.
                cli
                call    CS:oldint28
;
;      Determine if this TSR's HotKey has been flagged as pressed:
                cmp     CS:hotkeyflag,1 ;Has HotKey been pressed?
                jne     QuickExit       ;Exit if not.
;
                cmp     CS:bellgate,1   ;Is gate closed?
                je      QuickExit       ;If so, exit.
                mov     CS:bellgate,1   ;Else close gate and proceed.
;
                CLI                     ;DISABLE INTERRUPTS
;       If you are here, then HotKey has been pressed.
                push    ax              ;Entry for New Int. Handler.
                push    bx              ;Save all registers.
                push    cx
                push    dx
                push    si
                push    di
                push    bp
                push    ds
                push    es
;
                push    CS
                pop     DS
                ASSUME  DS:CodeSeg      ;v0.01
;
;
;       Make sure InDOS flag is no greater than 1. The InDOS flag equals
;       the number of DOS calls currently active. If we want to be sure
;       that we do not disrupt DOS by reentry in our TSR user routine,
;       we have to be sure that the present Int28 has occurred while
;       only 1-deep into DOS calls (as it is when DOS is TRULY idling):
                les     bx,indosptr             ;ES:bx points to InDOS flag.
                cmp     BYTE PTR ES:[bx],1      ;Is InDOS flag above 1?
                ja      Exit28                  ;Exit if InDOS > 1.
;
;       DOS is known to be idling at this point.
;      At this point, HotKey is known to have been pressed. Now we will
;      check to be sure that no time-critical hardware interrupt handling
;      is underway. We do this by querying the Intel 8259A Programmable
;      Interrupt Controller (PIC) chip's In Service Register (ISR) and
;      testing it to see that it is zero (i.e., nothing being serviced
;      except Int09 (PIC's IRQ1) ):
HotKeyPressed2:
                mov     al,ISRREQ       ;al=PIC's OCW3 to ask for ISR Register.
            out      PICPORT,al      ;Tell PIC to get ISR ready for reading.
            jmp      Dally2            ;Give PIC time to make ISR available.
Dally2:            in      al,PICPORT      ;Fetch the ISR Register from PIC.
;
;       Also, don't trigger the TSR if time-critical Disk access is underway:
                or      al,diskflag     ;al = ISR | diskflag. (| => Logical OR).
                jnz     Exit28          ;If al not zero, try again later.
;
;       Also, don't trigger the TSR if a PrtScrn is in progress:
;       (Is this really necessary? I don't think TSR will trigger during PrtSc)
                les     bx,prtscrn      ;ES:bx = pointer to PrtScrn busy flag.
                cmp     BYTE PTR es:[bx],1      ;Is PrtScrn in progress?
                je      Exit28                  ;If so, Exit w/o triggering TSR.
;
                STI                     ;ENABLE OTHER INTERRUPTS.
;
HotKeyFlagSet:
;      Here, HotKey is flagged as pressed and DOS is idling (since we are
;       servicing Int28h) and no hardware interrupts are being handled.
;       Also, no Print Screen or Disk access is underway.
;      DOS Int21h Functions above 0Ch can be accessed if required in your
;      TSR routine:
;
                call    ROUTINE         ;Call TSR routine; DOSOK & No Hardware
                              ;interrupts being serviced.
                mov     CS:hotkeyflag,0    ;Clear HotKey Flag.
;
Exit28:
                pop     es                      ;Restore all registers
                pop     ds
                ASSUME  ds:NOTHING
                pop     bp
            pop      di
            pop      si
            pop      dx
            pop      cx
            pop      bx
            pop      ax
                mov     CS:bellgate,0
;
QuickExit:
;       Return from this Keyboard Interrupt 28h handler routine:
                iret
;
NewInt28        ENDP            ;v0.01
;*************************************************************************
;      -END OF TSR's RESIDENT CODE-
;      Only the code above will remain locked in memory
;            after the initialization performed below.
;*************************************************************************
SUBTTL TSR BOOSTER (Initialization)
PAGE
;*************************************************************************
;       BEGINNING OF TSR's INITIALIZATION CODE (THE "BOOSTER"):
;      The following code is protected in RAM *ONLY* during initialization
;               of the TSR that occurs when the TSR name is first invoked
;            at the DOS command level. All the following code is abandonned
;               unprotected in RAM after the Terminate-and-Stay-Resident (TSR)
;            call to Function 31h of DOS Interrupt 21h below. This
;            is allowed to happen because the code's work is complete at
;            that point. The code will be overwritten as the memory which
;            it temporarily occupied is needed by DOS for other purposes.
;
;               I have seen this following section of code colorfully called
;               the TSR "Booster". This is quite appropriate since the code
;               sits here, strapped to the very end of the TSR, and it is of
;               use only during the "blastoff" (initialization) of the TSR, when
;               it is used to put the TSR into "orbit" (residency), and after
;               which it is "jettisoned" (abandonned unprotected in memory) by
;               the DOS TSR call, Int 21h, Fcn 31h.
;
TSRinit            PROC      NEAR                        ;v0.01
EndDump            EQU      $      ;Roy Silvernail - Keep TASM 1.0 happy
                        ;when computing # resident paragraphs.
;
;       Get DOS Version Number:
                mov     ah,30h                  ;Fcn 30h = Get DOS Version
                int     21h                     ;DOS Version = al.ah
;
;       If this is DOS v.1.x, this TSR cannot work, so go print message
;       and exit without installing:
                cmp     al,1         ;Is this DOS Version 1.x?
                ja      DOSverOK     ;If not, DOS version is OK.
                push    bx           ;A "push" for the "pop" at DOSver1 label.
                jmp     DOSver1      ;If so, TSR won't work so exit.
;
DOSverOK:
;       If here, DOS version is 2.0 or later. TSR can work, so proceed.
;
;       Check for prior installation of this TSR:
;
                mov     ax,TSRsigA              ;Prime registers for our
                mov     bx,TSRsigB              ;Int16h handler's check
                mov     cx,TSRsigC              ;for prior installation
                mov     dx,TSRsigD              ;thru TSR signature words.
;
                Int     16h                     ;Check prior installation.
;
                cmp     ax,TSRsigD              ;Was TSR signature detected?
                jne     Install                 ;If not, Install it.
                cmp     bx,TSRsigC
                jne     Install        
                cmp     cx,TSRsigB
                jne     Install        
                cmp     dx,TSRsigA
                jne     Install
;
; If you are here, all four TSR signature words were detected and signalled,
; so the TSR is already installed.
;       Announce the TSR's PRIOR Installation and exit:
                mov     dx,Offset PriorInstMsg  ;DX points to message.
                mov     ah,09h                  ;DOS Fcn. 09h=Display String.
                Int     21h                     ;Display String via DOS.
;
                mov     ax,4C00h                ;Fcn 4C = DOS Terminate call
                Int     21h                     ;Do it.
;
Install:
;       If you are here, then DOS version is 2.+ and the TSR has not
;       previously been installed.
;
;       To conserve RAM usage, release from memory the copy of the DOS
;      Environment passed to this TSR (this assumes, of course, that
;      your Interrupt handler routine will not need to reference this
;      de-allocated Environment) So, if you are going to write your
;      TSR routine to reference the Environment, DON'T DEALLOCATE IT
;      HERE.
;
                ;Get segment of Environment
            ;from 02Ch in the Program
            ;Segment Prefix (PSP).
;
                mov     ES,envseg       ;ES=PSP's environ seg   v0.01
                mov     ah,49h          ;DOS Fcn 49h = Release Memory
                int     21h             ;Release it via DOS interrupt.
;
; In order to make the TSR's command name show under the "owner" column in
;      the "MAPMEM" command of Kim Kokkonen's excellent TSR Mark/Release
;       package, allocate a tiny 1-paragraph "Pseudo-Environment" here which
;       contains nothing but the TSR name.
;
; Allocate the memory needed by the tiny 'Pseudo-Environment":
                mov     bx,1            ;Allocate one parag. (16bytes)
                mov     ah,48h          ;and return allocation
                int     21h             ;segment in ax via DOS call.
;
                mov     ES,ax           ;Pseudo-Env. Segment to ES.
            mov      si,OFFSET PseudoEnv      ;si=source string OFFSET.
                mov     di,0            ;di=destination string OFFSET.
                mov     cx,ENVLNGTH     ;cx=Bytes in Pseudo-Env.string.
                cld                     ;Forward string move direction.
            rep      movsb      ;Move Pseudo-Env. string @ DS:si to ES:di
;
; Set PSP's Environment segment pointer to point to tiny Pseudo-Environment.
            mov      envseg,ES      
;
;*****************************************************************************
; NOW, capture all the required Interrupts:
;
;       **** INT 09 ****
;       Get Old Interrupt 09h Vector:
                mov     ax,3500H+HOOK09 ;Get old Int 9 vector   v0.01
                int     21h             ;Int.Vector in ES:BX via DOS.
;
;      Save Old Interrupt 09h Vector:
            mov      Word Ptr oldint09,bx      ;Save Offset of Old Interrupt.
            mov      word ptr oldint09+2,ES      ;save seg            v0.01
;
;      Install New Interrupt Vector to this TSR's "NewInt09:" Label:
                mov     ax,2500H+HOOK09         ;Set new Int 9 vector   v0.01
            mov      dx,Offset NewInt09      ;dx=Offset of New Int Handler.
                int     21h                     ;Set New Int via DOS.
;
;       **** INT 13 ****
;       Get Old Interrupt 13h Vector:
                mov     ax,3500H+HOOK13         ;Get old Int 13 vector
                int     21h                     ;Int.Vector in ES:BX via DOS.
;
;       Save Old Interrupt 13h Vector:
                mov     Word Ptr oldint13,bx    ;Save Offset of Old Interrupt.
                mov     word ptr oldint13+2,ES  ;save Segment.
;
;       Install New Interrupt Vector to this TSR's "NewInt13:" Label:
                mov     ax,2500H+HOOK13         ;Set new Int 13 vector.
                mov     dx,Offset NewInt13      ;dx=Offset of New Int Handler.
                int     21h                     ;Set New Int via DOS.
;
;       **** INT 16 ****
;       Get Old Interrupt 16h Vector:
                mov     ax,3500H+HOOK16         ;get old Int 16H vector v0.01
                int     21h                     ;Int.Vector in ES:BX via DOS.
;
;      Save Old Interrupt 16h Vector:
                mov     Word Ptr oldint16,bx    ;Save Offset of Old Interrupt.
                mov     word ptr oldint16+2,ES  ;save segment           v0.01
;
;      Install New Interrupt Vector to this TSR's "NewInt16:" Label:
                mov     ax,2500H+HOOK16         ;set new Int 16H vector v0.01
                mov     dx,Offset NewInt16      ;dx=Offset of New Int Handler.
                int     21h                     ;Set New Int via DOS.
;
;       **** INT 28 ****
;      Get Old Interrupt 28h Vector:
                mov     ax,3500H+HOOK28         ;Get old Int 28H vector v0.01
                int     21h                     ;Int.Vector in ES:BX via DOS.
;
;      Save Old Interrupt 28h Vector:
                mov     Word Ptr oldint28,bx    ;Save Offset of Old Interrupt.
                mov     word ptr oldint28+2,ES  ;save segment           v0.01
;
;      Install New Interrupt Vector to this TSR's "NewInt28:" Label:
                mov     ax,2500H+HOOK28         ;set new Int 28H vector v0.01
                mov     dx,Offset NewInt28      ;dx=Offset of New Int Handler.
                int     21h                     ;Set New Int via DOS.
;
;*****************************************************************************
;       Get Pointer to InDOS flag ("DOS Busy" flag) and save it:
                mov     ah,34h                  ;DOS FCN=34h:Get InDOS Pointer.
                int     21h                     ;Pointer in ES:BX
                mov     Word Ptr indosptr,bx    ;Save Offset of InDOS flag.
                mov     Word Ptr indosptr+2,ES  ;Save Segment of InDOS flag.
;
                mov     Word Ptr criterrptr+2,ES ;Also, Seg of CritErr flag.
                push    bx      ;Save indosptr on stack for use below.
;
;       Get DOS Version Number:
                mov     ah,30h          ;Fcn 30h = Get DOS Version
                int     21h             ;DOS Version = al.ah
;
;       If DOS version is 2.x, then DOS Critical Error flag is @ indosptr + 1.
;       If DOS version is 3.x+, then DOS Critical Error flag is @ indosptr - 1.
;      Determine DOS Version:
                cmp     al,2            ;Is it DOS Version 2.x?
                je      DOSver2         ;If yes, jump;
                ja      DOSver3         ;or, if later version, jump;
                                        ;else, it's DOS Version 1.x:
;
DOSver1:        ;If here, DOS Version 1.x is being run:
                mov     dx,OFFSET BailOutMsg    ;TBONES needs DOS 2.x or later.
                mov     ah,09h                  ;Say we're sorry, but NO GO
                int     21h                     ;via DOS.
                pop     bx                      ;Clear stack.
                int     20h                     ;Terminate without installing
                                                ;in only way DOS 1.x knows.
;
DOSver2:        ;If here, DOS Version 2.x is being run:
                pop     bx                      ;Get indosptr from stack.
                inc     bx                      ;CritErr flag is @ indosptr+1.
                mov     Word Ptr criterrptr,bx  ;Save CritErr Pointer.
                jmp     Announce                ;Go announce TSR installed.
;
DOSver3:        ;If here, DOS Version 3.+ is being run:
                pop     bx                      ;Get indosptr from stack.
                dec     bx                      ;CritErr flag is @ indosptr-1.
                mov     Word Ptr criterrptr,bx  ;Save CritErr Pointer.
;
;      Announce the TSR's Installation:
Announce:
                mov     dx,Offset InstallMsg    ;DX points to message.
                mov     ah,09h                  ;DOS Fcn. 09h=Display String.
                int     21h                     ;Display String via DOS.
;
; Lock resident code in memory via Terminate-and-Stay-Resident (TSR) DOS call:
;
;v0.11      DX requires size of resident code (in 16-byte paragraphs)
;      This awkward construct is required to keep
;      DOS Function 31h happy.  Notice how we first compute
;      the length of the TSR code in bytes [i.e., end of
;      the TSR code (EndDump) minus start of the TSR code
;      (0, our BeginDump)], round it up to the next whole paragraph ( + 0Fh),
;      and then divide by 16 (SHR 4) to get the number of resident paragraphs:
;
                mov     dx,(EndDump-BeginDump+0Fh)/16
;Roy Silvernail discovered that the BeginDump and EndDump symbols
;were necessary to keep TASM 1.0 happy when computing # resident paragraphs
;in the above statement.
;
                mov     ah,31h                  ;DOS FCN 31h=TSR Call.
                int     21h                     ;Go Resident via DOS TSR call.
;
PseudoEnv:      DB      ' ',0,0,1,0,'TSRBONES',0
ENVLNGTH      EQU      $-PseudoEnv
;
BailOutMsg:
                db      0Dh,0Ah
                db      'Sorry. TSRBONES needs DOS v.2+. You have v.1.x'
                db      0Dh,0Ah,'$'
PriorInstMsg:
                db      0Dh,0Ah
                db      'TSRBONES IS *ALREADY* INSTALLED.'
InstallMsg:
                db      0Dh,0Ah
                db      'HotKey => Ctrl-Alt-B'
                db      0Dh,0Ah
                db      0Dh,0Ah
                db      'TSRBONES Version 0.1'
                db      0Dh,0Ah
                db      'Copyright (C) 1990 by Robert Curtis Davis'
                db      0Dh,0Ah,'$'
;
TSRinit         ENDP    ;v0.01

CodeSeg         ends
                end     Entry
;***********************************************************************
0

Featured Post

Receive 1:1 tech help

Solve your biggest tech problems alongside global tech experts with 1:1 help.

Question has a verified solution.

If you are experiencing a similar issue, please ask a related question

I’m willing to make a bet that your organization stores sensitive data in your Windows File Servers; files and folders that you really don’t want making it into the wrong hands.
The article explains the process to deploy a Self-Service password reset portal I developed a few years ago. Hopefully, it will prove useful to someone.  Any comments, bug reports etc. are welcome...
This lesson discusses how to use a Mainform + Subforms in Microsoft Access to find and enter data for payments on orders. The sample data comes from a custom shop that builds and sells movable storage structures that are delivered to your property. …
With just a little bit of  SQL and VBA, many doors open to cool things like synchronize a list box to display data relevant to other information on a form.  If you have never written code or looked at an SQL statement before, no problem! ...  give i…

580 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question