home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / keyboard / break / break.asm next >
Encoding:
Assembly Source File  |  1985-08-21  |  14.1 KB  |  597 lines
  1.     title BREAK - handle ctrl-break
  2.     include    m:dos.mac
  3. debug=0
  4.     subttl Documentation
  5. ;*****************************************************************************
  6. ; This code uses the standard Lattice interface.  The logical device 'm:'
  7. ; represents the memory model being used.  Supply your own path to dos.mac
  8. ;
  9. ; This code is intended to allow me to break out of various perverse
  10. ; loops in my application code.  
  11. ;
  12. ;              * * * W A R N I N G * * *
  13. ;
  14. ; This code is an extreme *HACK*.  It solves my problem.  It may not solve
  15. ; yours.  I make no guarantees.  Use at your own risk!
  16. ;
  17. ; It was tested using a Hercules monocrhome card.  I make no guarantees that
  18. ; I have done anything reasonable with respect to color cards.
  19. ;
  20. ;
  21. ;                 Restrictions
  22. ;
  23. ; The current code works only for the Lattice C compiler using the S or D
  24. ; models (64K program segment).  It depends upon the fact that the CS register
  25. ; is global to the entire code body.  It will probably not have the desired
  26. ; effect if you are executing out of the P or L models.
  27. ;
  28. ;
  29. ; Failure to clear the handler before exiting the program will lead to
  30. ; various bizarre behavior.  Calling the initialization more than once
  31. ; will confuse the world beyond practical recovery.
  32. ;
  33. ;                   Abstract
  34. ;
  35. ; A procedure is called to establish the existence of the control-break 
  36. ; handler (interrupt 1BH).  If a control-break is taken during program
  37. ; execution, and the CS:IP was in the user's code, execution is terminated.
  38. ;
  39. ; This code is to be linked into the user's application.
  40. ; 
  41. ;                Hacks
  42. ;
  43. ; What the initialization procedure does is record the CS: of the caller, 
  44. ; which in the small memory model must be the CS: of all the code.  It then
  45. ; sets up the interrupt 1BH to point to its intercept routine.
  46. ;
  47. ; The finalization procedure restores the interrupt vector 1BH to its previous
  48. ; value.
  49. ;
  50. ; The intercept routine uses the BIOS calls to write an informative message to
  51. ; the user.  It then reaches back into the stack a fixed number of bytes and
  52. ; examines the CS: at the time the interrupt from the keyboard was taken.
  53. ;
  54. ; BEWARE!  If you are not using the BIOS intercepts but are using any sort
  55. ; of keyboard extender (BUF160, ProKey, SuperKey) you will have to determine
  56. ; where this interrupt has stored the old CS:IP.  Have fun.
  57. ;
  58. ; If the CS: of the executing code (at the time the 1BH was taken) was in the
  59. ; user space, the IP: is modified to point to some termination code.  Normal
  60. ; return is then taken, except that when the BIOS exits the keyboard interrupt
  61. ; it returns to the exit control code and the process terminates.
  62. ;
  63. ;             Possible extensions
  64. ;
  65. ; SETCTL(x) where x is the address of a procedure could call an arbitrary
  66. ; procedure.  Note, however, that the old CS:IP is currently destroyed, so
  67. ; anyone extending this would have to make appropriate changes.
  68. ;
  69. ;               * * * B E W A R E * * *
  70. ;
  71. ; This code is delicate and high-risk.  It works well enough for my one
  72. ; application.  I may have missed all sorts of bizarre DOS or BIOS hacks.
  73. ;
  74. ; It is not guaranteed to be bug-free.  The user assumes all risk in using
  75. ; it.  This is code that should be used only if you understand enough of
  76. ; DOS/BIOS hacking to be sure it will work for you.
  77. ;
  78. ;
  79.  
  80.     subttl Interface specifications
  81. ;-----------------------------------------------------------------------------
  82. ; extern void SETCTL();
  83. ;    
  84. ; Effects: 
  85. ;    Establishes a Ctrl-brk abort handler
  86. ;
  87. ; Limitations:
  88. ;    May only be called once; subsequent calls may damage universe
  89. ; 
  90. ;-----------------------------------------------------------------------------
  91. ; extern void CLRCTL();
  92. ;
  93. ; Effects: 
  94. ;    Resets the Ctrl-brk abort handler
  95. ;
  96. ; Limitations:
  97. ;    Should be called only if SETCTL() has been called.  However, if
  98. ;    SETCTL has not already been called, nothing will happen.
  99. ;
  100. ;*****************************************************************************
  101.  
  102.     subttl Working storage
  103.  
  104. ; This storage is in the data segment
  105.  
  106.     DSEG
  107.  
  108. UserCS    DW    ?        ; CS: of where we were interrupted
  109. UserIP    DW    ?        ; IP: of where we were interrupted 
  110. UserIPL DW    ?        ; Address of user IP: (relative to seg reg)
  111. MyCS    DW    ?        ; CS: of where we were set up from
  112.  
  113. apage    DB    ?        ; Current display page
  114.     ENDDS
  115.  
  116.  
  117.     subttl Vector locations
  118. VECTORS    SEGMENT AT 0H
  119.     ORG    1BH*4        ; ctrl-brk interrupt interrupt 
  120. CTLBRK  LABEL    DWORD
  121. CTLBRK_IP DW            ; IP of control-break vector
  122. CTLBRK_CS DW            ; CS of control-break vector
  123. VECTORS ENDS
  124.  
  125.  
  126.  
  127.     subttl  Code segment storage 
  128. ;
  129. ; This is in the code segment because I don't know how to make it addressible
  130. ; in the data segment
  131. ;
  132.     PSEG
  133.  
  134. OLD_REQ    label    DWORD        ; we store former 1BH vector here
  135. OLD_IP    DW    0        ; 0, not ?
  136. OLD_CS    DW    0        ; 0, not ?
  137.  
  138. OldAX    DW    ?
  139. OldSS    DW    ?        ; old stack segment
  140. OldSP    DW    ?        ; old stack pointer
  141.     DW    512 DUP(?)    ; local stack space for intercept routine
  142. STACK    label    WORD
  143.  
  144.     subttl  wdigit - Write a hex digit
  145. ;-----------------------------------------------------------------------------
  146. ;                    wdigit
  147. ;
  148. ; Inputs:
  149. ;    AX: Single hex digit to convert (0..15)
  150. ;    BX: Place to put it
  151. ;
  152. ; Effects:
  153. ;    AX is converted from binary to hex and placed at the location
  154. ;    defined by ES:BX
  155. ; Modified:
  156. ;    AX
  157. ;-----------------------------------------------------------------------------
  158. wdigit    PROC    NEAR
  159.     push    DI            ; ... working registers
  160.     push    SI
  161.     mov    DI,BX            ; get destination
  162.     and    AX,0FH            ; mask off l/o bits
  163.     add    AX,OFFSET TBL        ; get address of decoded byte
  164.     mov    SI,AX            ; make available for indexing
  165.     mov    AL,CS:[SI]        ; get the byte "0".."F"
  166.     mov    ES:[DI],AL        ; store it at the destination
  167.     pop    SI            ; ...restore working regs
  168.     pop    DI
  169.     ret                ; return
  170. wdigit    ENDP
  171.  
  172. TBL:    DB    '0123456789ABCDEF'    ; hex digit decode table
  173.  
  174.     subttl    cvt1
  175. ;-----------------------------------------------------------------------------
  176. ;                     cvt1
  177. ;
  178. ; Inputs:
  179. ;    AX: Word to convert
  180. ;    ES:BX Place to put character
  181. ;
  182. ; Effects:
  183. ;    Converts l/o bits of AX to character, places character at ES:BX
  184. ;    decrements BX, shifts AX right 4 bits
  185. ;
  186. ; Output conditions:
  187. ;    BX--
  188. ;    AX >>= 4
  189. ;-----------------------------------------------------------------------------
  190. cvt1    PROC    NEAR
  191.     push    AX    ; save AX
  192.     call    wdigit        ; write digit to buffer ES:BX
  193.     pop    AX        ; get old AX
  194.     SHR    AX,1        ; shift right 4
  195.     SHR    AX,1        ; ...
  196.     SHR    AX,1        ; ...
  197.     SHR    AX,1        ; ...
  198.     dec    BX        ; select next higher character position
  199.     ret
  200. cvt1    ENDP
  201.  
  202.  
  203.  
  204.     subttl  cvt - convert binary to hex
  205. ;-----------------------------------------------------------------------------
  206. ; Inputs:
  207. ;    AX - value to convert
  208. ;    ES:BX - place to put it
  209. ;
  210. ; Effects:
  211. ;    Converts binary value in AX to 4-digit hex value and places it in
  212. ;    location indexed by BX (BX points to low-order position, and is
  213. ;    decremented for each position
  214. ;
  215. ; Modified:
  216. ;    AX, BX
  217. ;-----------------------------------------------------------------------------
  218. cvt    PROC    NEAR
  219.  
  220.     call    cvt1        ; write first digit
  221.     call    cvt1        ; write second digit
  222.     call    cvt1        ; write third digit
  223.     call    cvt1        ; write fourth digit
  224.     ret
  225.  
  226. cvt    ENDP
  227.  
  228.     subttl    CTLSEEN - CTRL-BREAK handler
  229. ;-----------------------------------------------------------------------------
  230. ;                    ctlseen
  231. ; Inputs:
  232. ;    None; called as interrupt routine via interrupt 1BH
  233. ;
  234. ; Result:
  235. ;    AL=0FFH
  236. ;
  237. ; Effects:
  238. ;     Issue message: 'Ctrl-brk seen at use PC xxxx:xxxx'
  239. ;
  240. ;      If called from user program, sets up user CS:IP return value to
  241. ;    return to "exit code" which is call on C '_exit' routine.
  242. ;
  243. ;-----------------------------------------------------------------------------
  244.  
  245. CTLSEEN    PROC FAR
  246.  
  247.  
  248. if debug
  249.     int  3
  250. endif
  251. ; Set up user stack
  252.  
  253.     mov    OldSS,SS    ; Save old stack
  254.     mov    OldSP,SP    ; ...
  255.     mov    OldAX,AX    ; save AX
  256.     cli            ; interrupts off
  257.     mov    AX,CS        ; Get CS: so we can make our local stack
  258.                 ; addressible
  259.     mov    SS,AX        ; New stack segment
  260.     mov    SP,offset STACK    ; ...
  261.     sti            ; interrupts back on
  262.  
  263.     push    BX        ; Save us some working regs
  264.     push    CX        ; ...
  265.     push    DX        ; ...
  266.     push    ES        ; ...
  267.     push    BP        ; ...
  268.     push    DS        ; ...
  269.     
  270.     mov    AX,OldSP    ; We want to look at the user stack
  271.     mov    ES,OldSS    ; which will be in ES:AX
  272.  
  273. ; AX is the top of the stack upon entry (before stack switching)
  274. ;
  275. ;       +---------------+
  276. ;  AX ---> |      IP       | +0        ; return point to Interrupt handler
  277. ;       +---------------+
  278. ;       |      CS       | +2        ; return point to interrupt handler
  279. ;       +---------------+
  280. ;       |     flags     | +4
  281. ;       +---------------+
  282. ;       |      BP       | +6        ; saved regs
  283. ;       +---------------+
  284. ;       |      AX       | +8
  285. ;       +---------------+
  286. ;       |      BX       | +10
  287. ;       +---------------+
  288. ;       |      CX       | +12
  289. ;       +---------------+
  290. ;       |      DX       | +14
  291. ;       +---------------+
  292. ;       |      SI       | +16
  293. ;       +---------------+
  294. ;       |      DI       | +18
  295. ;       +---------------+
  296. ;       |      DS       | +20
  297. ;       +---------------+
  298. ;       |      ES       | +22
  299. ;       +---------------+
  300. ;       | User IP       | +24    ; return to user code
  301. ;       +---------------+
  302. ;       | User CS       | +26    ; return to user code
  303. ;       +---------------+
  304.  
  305. ; Establish addressibility of DS
  306.  
  307. ; DS := Seg(&UserIP);
  308.  
  309.     mov    BX,SEG UserIP        ; make our data area available by
  310.                     ; using SEG of some variable in it
  311.     mov    DS,BX            ; to DS:
  312.  
  313.     mov    BP,AX            ; AX is now in BP, so ES:BP holds
  314.                     ; old SS:SP
  315. ; UserIP := * (OldSS:(OldSP+24))
  316.  
  317.     mov    AX,ES:[BP+24]        ; Magic offset!  Get user IP
  318.     mov    UserIP,AX        ; Store it for later use
  319.     lea    AX,ES:[BP+24]        ; Magic offset!  Get address of where
  320.                     ; it was
  321. ; UserIPL :=  (OldSS:(OldSP+24))
  322.     mov    UserIPL,AX        ; Store this as the UserIP Location
  323.  
  324. ; UserCS := * (OldSS:(OldSP+26))
  325.  
  326.     mov    AX,ES:[BP+26]        ; Magic offset! Get user CS:
  327.     mov    UserCS,AX        ; Save it for later use
  328.  
  329. ; Video_state(&apage)
  330.  
  331.     mov    AH,15        ; return video state
  332.     int    10H
  333.                 ; AH = current video mode
  334.                 ; AL = #of columns on screen    
  335.     mov    apage,BH    ; active page in BH
  336.  
  337. ; /* Convert CS: to hex */
  338.  
  339. ;    cvt(UserCS,&MSGCS)
  340. ;        /* call cvt(AX,ES:BX) */
  341. ;    
  342.     mov    AX,CS        ; Get CS: to make msg addressible
  343.     mov    ES,AX        ; Put in ES
  344.     mov    BX,OFFSET MSGCS    ; ES:BX = Place to put digits
  345.  
  346.     mov    AX,UserCS    ; AX gets value to put into message
  347.     call    cvt        ; Go convert it, modifying message
  348.  
  349. ; /* Convert IP: to hex */
  350.  
  351. ;    cvt(UserIP,&MSGIP)
  352. ;        /* call cvt(AX,ES:BX) */
  353. ;    
  354.     mov    AX,CS        ; Get CS: to make msg addressible
  355.     mov    ES,AX        ; put in ES
  356.     mov    BX,OFFSET MSGIP    ; ES:BX = place to put digits
  357.  
  358.     mov    AX,UserIP    ; AX gets value to put into message
  359.     call    cvt        ; Go convert it, modifying message
  360.  
  361. ; Write_string(mode=0,Attr=rev,string=MSG1,length=MSG1L,CursorX=0,CursorY=24,page=apage)
  362.  
  363.     ; ES:BP = &MSG1;   /* string */
  364.  
  365.     mov    AX,CS
  366.     mov    ES,AX
  367.     mov    BP,OFFSET MSG1
  368.  
  369.     ; CX = strlen(MSG1); /* length */
  370.  
  371.     mov    CX,MSG1L
  372.  
  373.     ; DH = 24;        /* CursorY */
  374.  
  375.     mov    DH,24
  376.  
  377.     ; DL = 0;        /* CursorX */
  378.  
  379.     mov    DL,0
  380.  
  381.     ; BH = apage;        /* page */
  382.  
  383.     mov    BH,apage
  384.  
  385.     ; AL = 1;        /* mode: 1 -> BL has attr, string has chars,
  386.     ;            move cursor */
  387.  
  388.     mov    AL,1            ; 
  389.  
  390.     ; BL = 70H;        /* attribute: 70H = Reverse video block */
  391.  
  392.     mov    BL,70H            ; 
  393.  
  394.     mov    AH,19            ; write string
  395.     int    10H            ; ...
  396.  
  397.  
  398. ; /* If we came from the user's program, abort */
  399.  
  400. ; if(UserCS == MyCS) _exit()
  401.  
  402. ; /* Store the IP of the abort code in the return pointer, then return     */
  403.     mov    AX,UserCS
  404.     cmp    AX,MyCS
  405.     jne    NotMe            ; not in my program, go on
  406.  
  407.     mov    BP,UserIPL        ; get address of user IP
  408.     mov    AX,OFFSET ByeBye    ; plan to die upon return
  409.     mov    ES,OldSS        ; make segment addressible
  410.     mov    ES:[BP],AX        ; store the updated pointer
  411.  
  412. NotMe:
  413.  
  414.  
  415. ; /* Otherwise, continue as if we weren't here */
  416.  
  417.     pop    DS
  418.     pop    BP
  419.     pop    ES
  420.     pop    DX
  421.     pop    CX
  422.     pop    BX
  423.  
  424. ; /* Reset to old user stack */
  425.  
  426.     cli
  427.     mov    SS,OldSS
  428.     mov    SP,OldSP
  429.     sti
  430.     mov    AX,OldAX
  431.  
  432.  
  433. ; /* Now go to the real handler */
  434.  
  435.     jmp    OLD_REQ
  436.  
  437. CTLSEEN    ENDP
  438.  
  439. ; The message and its various subcomponents
  440.  
  441. MSG1:    DB    'Ctrl-break at PC '
  442.     DB    'xxxx'
  443. MSGCS    equ    $-1
  444.     DB    ':'
  445.     DB    'xxxx'
  446. MSGIP    equ    $-1
  447.  
  448.     DB    0DH,0AH        ; CR,LF
  449. MSG1L   equ     $-MSG1
  450.  
  451.     subttl    SETCTL - Set CTL-BRK vector
  452. ;-----------------------------------------------------------------------------
  453. ; extern void SETCTL()
  454. ;-----------------------------------------------------------------------------
  455.  
  456.     PUBLIC    SETCTL
  457.     IF LPROG
  458. SETCTL    PROC    FAR
  459.     ELSE
  460. SETCTL     PROC NEAR            ; set CTL-BRK interrupt
  461.     ENDIF
  462.     push    BP            ; C prolog
  463.     mov    BP,SP            ; ...
  464.  
  465. ; MyCS := CS;
  466.     mov    MyCS,CS            ; save CS
  467.  
  468.     ASSUME ES:VECTORS
  469.  
  470. ; OldES := ES;
  471.  
  472.     push    ES        ; save old ES
  473.     push    AX        ; save old AX
  474.  
  475. ; ES := Segment(&Vectors);
  476.  
  477.     mov    AX,VECTORS
  478.     mov    ES,AX        
  479.  
  480. ; Disable_Interrupts();
  481.  
  482.     CLI            ; turn off interrupts
  483.  
  484. ; OLD_REQ.IP := CTLBRK.IP
  485.  
  486.     mov    AX,CTLBRK
  487.     mov    OLD_REQ,AX
  488.  
  489. ; OLD_REQ.CS := CTLBRK.CS
  490.  
  491.     mov    AX,CTLBRK[2]
  492.     mov    OLD_REQ[2],AX
  493.  
  494. ; CTLBRK := &CTLSEEN
  495.  
  496.     mov    CTLBRK_IP,OFFSET CTLSEEN
  497.     mov    CTLBRK_CS,CS
  498.  
  499. ; Enable_interrupts();
  500.  
  501.     STI        ; allow interrupts
  502.  
  503. ; ES := OldES;
  504.  
  505.     pop    AX
  506.     pop    ES    
  507.  
  508. ; return;
  509.     pop    BP    ; C epilog
  510.     ret        ; return to caller
  511.  
  512. ; This is the User Exit routine
  513.  
  514.     IF LPROG
  515.     extrn    _Exit:Far
  516.     ELSE
  517.     extrn    _Exit:Near
  518.     ENDIF
  519.  
  520. ByeBye:    
  521.     call    CLRCTL
  522.     call    _Exit
  523.  
  524. SETCTL    ENDP
  525.  
  526.     subttl    CLRCTL - Clear CTL-BRK vector
  527. ;-----------------------------------------------------------------------------
  528. ; extern void CLRCTL();
  529. ;
  530. ; Resets the ctrl-break interrupt vector
  531. ;-----------------------------------------------------------------------------
  532.     PUBLIC    CLRCTL
  533.     IF    LPROG
  534. CLRCTL PROC FAR
  535.     ELSE
  536. CLRCTL PROC NEAR
  537.     ENDIF
  538.     ASSUME ES:VECTORS
  539.  
  540.  
  541. ; OldES := ES;
  542.  
  543.     push    ES        ; save old ES
  544.     push    AX        ; save old AX
  545.     push    BX
  546.  
  547. if debug
  548.     int 3
  549.     mov    AH,62H
  550.     int    21H        ; get program segment prefix
  551.     mov    PSP,BX        ; save it
  552. endif
  553.  
  554. ; ES := Segment(&Vectors);
  555.  
  556.     mov    AX,VECTORS
  557.     mov    ES,AX        
  558.  
  559. ; Disable_Interrupts();
  560.  
  561.     CLI            ; turn off interrupts
  562.  
  563. ; if(OLD_REQ == 0) goto NoVectorStored
  564.  
  565.     mov    AX,OLD_REQ
  566.     cmp    AX,0        ; is it zero?
  567.     je    NoVectorStored
  568.  
  569. ; CTLBRK.IP := OLD_REQ.IP
  570.  
  571.     mov    CTLBRK,AX
  572.  
  573. ; CTLBRK.CS := OLD_REQ.CS
  574.  
  575.     mov    AX,OLD_REQ[2]
  576.     mov    CTLBRK[2],AX
  577.  
  578. NoVectorStored:
  579.  
  580. ; Enable_interrupts();
  581.  
  582.     STI        ; allow interrupts
  583.  
  584. ; ES := OldES;
  585.  
  586.     pop    BX
  587.     pop    AX
  588.     pop    ES    
  589.  
  590.     ret        ; return to caller
  591.  
  592. PSP:    DW    ?
  593. CLRCTL  ENDP
  594.  
  595.     ENDPS
  596.     END
  597.