home *** CD-ROM | disk | FTP | other *** search
/ For Beginners & Professional Hackers / cd.iso / docum / dos-ref.doc / examples / chap5.arj / TSREXAMP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-26  |  15.4 KB  |  556 lines
  1. /* 
  2. TSREXAMP.C
  3. by Raymond J. Michels
  4. with revisions by Tim Paterson
  5. and Andrew Schulman
  6. */
  7.  
  8. #include <stddef.h>
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <conio.h>
  12. #include <dos.h>
  13. #include <bios.h>
  14. #include "tsr.h"
  15.  
  16. #define STACK_SIZE      8192  /* must be 16 byte boundaray */
  17. #define SET_DTA         0x1a  /* SET Disk Transfer Address */
  18. #define GET_DTA         0x2f  /* GET Disk Transfer Address */   
  19.  
  20. #define DOS_EXIT        0x4C  /* DOS terminate (exit) */
  21.  
  22. #define KEYBOARD_PORT   0x60  /* KEYBOARD Data Port */
  23.  
  24. #define PSP_TERMINATE   0x0A  /* Termination addr. in our PSP */
  25. #define PSP_PARENT_PSP  0x16  /* Parent's PSP from our PSP */
  26. #define PSP_ENV_ADDR    0x2c  /* environment address from PSP */
  27.  
  28. #define HOT_KEY         32    /* Hot Key along with ALT (D)*/
  29.  
  30. #define RIGHT_SHIFT     1
  31. #define LEFT_SHIFT      2
  32. #define CTRL_KEY        4
  33. #define ALT_KEY         8
  34.  
  35. #define MULTIPLEX_ID    0xC0
  36. #define INSTALL_CHECK   0x00
  37. #define INSTALLED       0xFF
  38. #define DEINSTALL       0x01
  39.  
  40. #define PARAGRAPHS(x)   ((FP_OFF(x) + 15) >> 4)
  41.  
  42. unsigned char multiplex_id = MULTIPLEX_ID;    
  43. char far *stack_ptr;           /* pointer to TSR stack */
  44. unsigned ss_save;              /* slot for stack segment register */
  45. unsigned sp_save;              /* slot for stack pointer register */
  46. int tsr_already_active = 0;    /* true if TSR active */
  47. int popup_while_dos_busy = 0;  /* true if hot key hit while dos busy */
  48. int int_28_in_progress = 0;    /* true if INT 28 in progress */
  49. int unsafe_flag = 0;           /* true if INT 13 in progress */
  50. unsigned keycode;                
  51. unsigned foreground_psp;       /* PSP of process we've interrupted */
  52. unsigned foreground_dta_seg;   /* DTA of process we've interrupted */
  53. unsigned foreground_dta_off;
  54. char buf[20];                  /* work buffer */
  55. unsigned long TerminateAddr;   /* used during de-install */
  56. union REGS regs;               /* register work structures */
  57. struct SREGS sregs;     
  58. struct ExtErr ErrInfo;         /* save area for extended error info */
  59. int hot_key;                   /* keycode for activation */
  60. int shift_key;                 /* shift status bits (alt,  ctrl..) */
  61. int user_key_set = 0;
  62.     
  63. /* Save areas for old interrupt pointers */
  64. INTVECT old_int8, old_int9, old_int10, old_int13, old_int1b, old_int23;
  65. INTVECT old_int24, old_int28, old_int2f;
  66.  
  67. #ifdef DOS_SWAP
  68. extern int dos_critical;     /* used by DOSSWAP.C */
  69. INTVECT old_int2a;
  70. void interrupt far new_int2a(INTERRUPT_REGS);
  71. #endif
  72.  
  73. /* PROTOTYPES FOR THIS MODULE */
  74. void interrupt far new_int8(INTERRUPT_REGS);
  75. void interrupt far new_int9(INTERRUPT_REGS);
  76. extern void interrupt far new_int13(void);  /* in TSRUTIL.ASM */
  77. void interrupt far new_int1b(INTERRUPT_REGS);
  78. void interrupt far new_int23(INTERRUPT_REGS);
  79. void interrupt far new_int24(INTERRUPT_REGS);
  80. void interrupt far new_int28(INTERRUPT_REGS);
  81. void interrupt far new_int2f(INTERRUPT_REGS);
  82. void tsr_function(void);
  83. void tsr_exit(void);
  84. void usage(char *);
  85. int UnlinkVect(int Vect, INTVECT NewInt, INTVECT OldInt);
  86. void parse_cmd_line(int argc, char *argv[]);
  87. void main(int argc,char *argv[]);
  88.  
  89. /*********
  90. * TIMER INTERRUPT HANDLER
  91. *********/
  92. void interrupt far new_int8(INTERRUPT_REGS r)
  93. {
  94. #ifdef DOS_SWAP
  95.     if (!tsr_already_active && popup_while_dos_busy &&
  96.         !dos_critical && !unsafe_flag)
  97. #else
  98.     if (!tsr_already_active && popup_while_dos_busy &&
  99.         !DosBusy() && !unsafe_flag) 
  100. #endif
  101.     {
  102.         popup_while_dos_busy = 0;
  103.         tsr_already_active = 1;
  104.         (*old_int8)();    /* process timer tick */
  105.         _enable(); /* turn interrupts back on */
  106.         tsr_function();
  107.         tsr_already_active = 0;
  108.     }
  109.     else
  110.         (*old_int8)();    /* process timer tick */
  111. } 
  112.  
  113. /**********
  114. * KEYBOARD INTERRUPT HANDLER
  115. **********/
  116. void interrupt far new_int9(INTERRUPT_REGS r)
  117. {
  118.     if (! tsr_already_active)
  119.     {
  120.          if ((keycode = inp(KEYBOARD_PORT)) != hot_key)
  121.             _chain_intr(old_int9);
  122.  
  123.          if ((_bios_keybrd(_KEYBRD_SHIFTSTATUS) & 
  124.             shift_key) == shift_key)
  125.          {      
  126. #ifdef USES_DISK
  127.             if (!unsafe_flag)
  128.             {
  129. #endif
  130.                 popup_while_dos_busy = 0;   
  131.                 tsr_already_active = 1;
  132.                 (*old_int9)();     /* send key to old int routine */
  133.                 tsr_function();
  134.                 tsr_already_active = 0; 
  135.  
  136. #ifdef USES_DISK
  137.             }
  138.             else
  139.             {
  140.                 popup_while_dos_busy = 1;
  141.                 _chain_intr(old_int9);
  142.             }
  143. #endif
  144.          }
  145.          else
  146.             _chain_intr(old_int9);
  147.      }      
  148.      else 
  149.          _chain_intr(old_int9);     
  150. } 
  151.  
  152. /*********
  153. * CTRL-BREAK INTERRUPT HANDLER
  154. *********/
  155. void interrupt far new_int1b(INTERRUPT_REGS r)
  156. {
  157.     /* do nothing */
  158. } 
  159.  
  160. /**********
  161. * CTRL-C INTERRUPT HANDLER
  162. **********/
  163. void interrupt far new_int23(INTERRUPT_REGS r)
  164. {
  165.     /* do nothing */
  166. } 
  167.  
  168. /**********
  169. * CRTITICAL ERROR INTERRUPT HANDLER
  170. **********/
  171. void interrupt far new_int24(INTERRUPT_REGS r)
  172. {
  173.     if (_osmajor >= 3)
  174.         r.ax = 3;   /* fail dos function */
  175.     else
  176.         r.ax = 0;        
  177. } 
  178.  
  179. /**********
  180. * DOS IDLE INTERRUPT HANDLER
  181. **********/
  182. void interrupt far new_int28(INTERRUPT_REGS r)
  183. {
  184.     int_28_in_progress++;
  185.  
  186. #ifdef DOS_SWAP
  187.     if (popup_while_dos_busy && !dos_critical 
  188.         && !tsr_already_active && !unsafe_flag)
  189. #else
  190.     if (popup_while_dos_busy && (!Int28DosBusy()) 
  191.         && !tsr_already_active && !unsafe_flag) 
  192. #endif
  193.     {
  194.          tsr_already_active = 1;
  195.          tsr_function();
  196.          tsr_already_active = 0;
  197.     }
  198.  
  199.     int_28_in_progress--;
  200.     _chain_intr(old_int28);  
  201. } 
  202.  
  203. #ifdef DOS_SWAP
  204. /*********
  205. * DOS INTERNAL INTERRUPT HANDLER
  206. *********/
  207. void interrupt far new_int2a(INTERRUPT_REGS r)
  208. {
  209.    switch (r.ax & 0xff00)
  210.    {
  211.       case 0x8000:    /* start critical section */
  212.          dos_critical++;
  213.          break;
  214.       case 0x8100:    /* end critical section */
  215.       case 0x8200:    /* end critical section */
  216.          if (dos_critical)    /* don't go negative */
  217.             dos_critical--;
  218.          break;
  219.       default:
  220.          break;
  221.     }
  222.    _chain_intr(old_int2a);
  223. } 
  224. #endif
  225.  
  226. /*********
  227. * DOS MULTIPLEX INTERRUPT HANDLER
  228. *********/
  229. void interrupt far new_int2f(INTERRUPT_REGS r)
  230. {
  231.     unsigned ah = r.ax >> 8;
  232.     unsigned al = r.ax & 0xFF;
  233.     
  234.     if (ah == multiplex_id)
  235.     {
  236.         if (al == INSTALL_CHECK)
  237.             r.ax |= INSTALLED;
  238.         else if (al == DEINSTALL)
  239.         {
  240.             // because of stack swap, pass arg in static variable.
  241.              TerminateAddr = ((long)r.bx << 16) + r.dx;
  242.              if (! tsr_already_active)  /* don't exit if we're active */
  243.              {
  244.                  _enable(); /* STI */
  245.                  tsr_exit();
  246.                  // If we got here, we weren't able to unlink
  247.                  r.ax = 0xFFFF;  //let caller know we're still there
  248.                  // MSC 6.0 /Ox optimizes the above instruction away
  249.                  // get it back by using the value in ax
  250.                  tsr_already_active = -r.ax;  
  251.                  // set to 1 to prevent any more action
  252.              }
  253.          }
  254.     }
  255.     else
  256.          _chain_intr(old_int2f);
  257. } 
  258.  
  259. /**********
  260. * TSR ACTIVE SECTION
  261. **********/
  262. void tsr_function()
  263. {
  264.     set_stack();
  265.  
  266. #ifdef DOS_SWAP
  267.     if (SaveDosSwap() && !int_28_in_progress)
  268. #else
  269.     if (DosBusy() && !int_28_in_progress)
  270. #endif
  271.         popup_while_dos_busy = 1; /* set flag: next INT 8,28 activates us */
  272.     else
  273.     {
  274.         popup_while_dos_busy = 0;
  275.  
  276.         /* save old interrupt-CTRL-BREAK, CTRL-C and CRIT ERROR */ 
  277.         old_int1b = _dos_getvect(0x1b); 
  278.         old_int23 = _dos_getvect(0x23); 
  279.         old_int24 = _dos_getvect(0x24); 
  280.  
  281.         /* set our interrupts functions */
  282.        _dos_setvect(0x1b, new_int1b);
  283.        _dos_setvect(0x23, new_int23);
  284.        _dos_setvect(0x24, new_int24);
  285.  
  286.         /* save current PSP and set to ours */
  287.         /* not needed for DOSSWAP, but can be used by application */
  288.         foreground_psp = GetPSP();
  289.  
  290.         SetPSP(_psp);   // _psp in STDLIB.H
  291.  
  292. #ifndef DOS_SWAP
  293.         /* get foreground DTA */
  294.         regs.h.ah = GET_DTA;
  295.         intdosx(®s, ®s, &sregs); 
  296.         foreground_dta_seg = sregs.es;
  297.         foreground_dta_off = regs.x.bx;
  298. #endif
  299.  
  300.         /* set up our DTA */
  301.         regs.h.ah = SET_DTA;
  302.         regs.x.dx = 0x80;   /* use default in PSP area */
  303.         sregs.ds = _psp;
  304.         intdosx(®s, ®s, &sregs); 
  305.  
  306. #ifndef DOS_SWAP
  307.         /* Get Extended Error Information */
  308.         GetExtErr(&ErrInfo);
  309. #endif
  310.  
  311.         /* suck up key(s) in buffer */
  312.         while (_bios_keybrd(_KEYBRD_READY))
  313.            _bios_keybrd(_KEYBRD_READ);
  314.  
  315.         /* your code goes here */
  316.         application();
  317.  
  318. #ifdef DOS_SWAP
  319.         RestoreDosSwap();
  320. #else
  321.         /* put back extended error information */
  322.         SetExtErr(&ErrInfo);
  323.  
  324.         /* put back original DTA */
  325.         regs.h.ah = SET_DTA;
  326.         regs.x.dx = foreground_dta_off; 
  327.         sregs.ds  = foreground_dta_seg;
  328.         intdosx(®s, ®s, &sregs); 
  329.  
  330.         /* put back original PSP */
  331.         SetPSP(foreground_psp);
  332. #endif
  333.  
  334.         /* put back original INTS */
  335.        _dos_setvect(0x1b, old_int1b);
  336.        _dos_setvect(0x23, old_int23);
  337.        _dos_setvect(0x24, old_int24);
  338.     }
  339.  
  340.     restore_stack();
  341. }
  342.  
  343. // only restores OldInt if someone hasn't grabbed away Vect
  344. int UnlinkVect(int Vect, INTVECT NewInt, INTVECT OldInt)
  345. {
  346.     if (NewInt == _dos_getvect(Vect))
  347.     {
  348.         _dos_setvect(Vect, OldInt);
  349.         return 0;
  350.     }
  351.     return 1;
  352. }
  353.  
  354. void tsr_exit(void)
  355. {
  356.     set_stack();
  357.     /* put interrupts back the way they were, if possible */
  358.  
  359.     if (!(UnlinkVect(8, new_int8, old_int8)      |
  360.           UnlinkVect(9, new_int9, old_int9)      |  // Do not use ||, we
  361.           UnlinkVect(0x28, new_int28, old_int28) |  // don't want early out
  362.           UnlinkVect(0x13, new_int13, old_int13) |
  363. #ifdef DOS_SWAP
  364.           UnlinkVect(0x2a, new_int2a, old_int2a) |
  365. #endif
  366.           UnlinkVect(0x2f, new_int2f, old_int2f) ))
  367.     {
  368.         // Set parent PSP, stored in our own PSP, to the current PSP
  369.         *(int far *)(((long)_psp << 16) + PSP_PARENT_PSP) = GetPSP();
  370.  
  371.         // Set terminate address in our PSP
  372.         *(long far *)(((long)_psp << 16) + PSP_TERMINATE) = TerminateAddr;
  373.  
  374.         /* set psp to be ours */
  375.         SetPSP(_psp);
  376.  
  377.         /* exit program */
  378.         bdos(DOS_EXIT, 0, 0);
  379.     }
  380.     restore_stack();
  381. }
  382.  
  383. void usage(char *progname)
  384. {
  385.     fputs("Usage: ", stdout);
  386.     puts(progname);
  387.     puts(" [-d to deinstall] [-k keycode shift-status] [-f multiplex id]");
  388.     puts(" Valid multiplex id");
  389.     puts("    00 through 15 specifies a unique INT 2F ID");
  390.     puts(" Valid shift-status is any combination of:");
  391.     puts("    1 = Right Shift");
  392.     puts("    2 = Left Shift");
  393.     puts("    4 = CTRL");
  394.     puts("    8 = ALT");
  395.     exit(1);
  396. }
  397.  
  398. void do_deinstall(char *progname)
  399. {
  400.     fputs(progname, stdout);
  401.     switch (deinstall())
  402.     {
  403.         case 1:
  404.             puts(" was not installed");
  405.             break;
  406.         case 2:
  407.             puts(" deinstalled");
  408.             break;
  409.         default:
  410.             puts(" deactivated but not removed");
  411.             break;
  412.     }
  413.     exit(0);
  414. }
  415.  
  416. int set_shift_key(unsigned sh)
  417. {
  418.     /* figure out, report on shift statuses */
  419.     /* make sure shift key < 0x10 and non-zero */
  420.     if (((shift_key = sh) < 0x10) && shift_key)
  421.     {
  422.         printf("Activation: %s%s%s%sSCAN=%d\n",
  423.         shift_key & RIGHT_SHIFT ? "RIGHT " : "",
  424.         shift_key & LEFT_SHIFT ? "LEFT " : "",
  425.         shift_key & CTRL_KEY ? "CTRL " : "",
  426.         shift_key & ALT_KEY ? "ALT " : "",
  427.           hot_key);
  428.         return 1;
  429.     }
  430.     else /* error, bad param */
  431.     {
  432.       puts("Invalid Shift-Status");
  433.       return 0;
  434.     }
  435. }
  436.                     
  437. void parse_cmd_line(int argc, char *argv[])
  438. {
  439.     int i;
  440.     int tmp;
  441.  
  442.     for (i = 1; i < argc; i++)   /* for each cmdline arg */
  443.         if ((argv[i][0] == '-') || (argv[i][0] == '/'))
  444.             switch(toupper(argv[i][1]))
  445.             {
  446.                 case 'D':
  447.                     do_deinstall(argv[0]);
  448.                     break;
  449.                 case 'K':    /* set pop-up key sequence */          
  450.                     user_key_set = 1;
  451.                     i++;     /* bump to next argument */
  452.                     if ((hot_key = atoi(argv[i])) != 0)
  453.                     {
  454.                         i++;   /* bump to next argument */
  455.                         if (! set_shift_key(atoi(argv[i])))
  456.                             usage(argv[0]);
  457.                     }
  458.                     else
  459.                         usage(argv[0]);
  460.                     break;
  461.                 case 'F':   /* set multiplex ID */
  462.                     i++;    /* bump to next argument */
  463.                     if ((tmp = atoi(argv[i])) < 0x10)                    
  464.                         multiplex_id += tmp; /* range of C0-CF */
  465.                     else
  466.                         usage(argv[0]);
  467.                     break;
  468.                 default:    /* invalid argument */
  469.                     usage(argv[0]);
  470.             }   /* end switch */
  471.         else
  472.             usage(argv[0]);
  473. }
  474.  
  475. void main(int argc,char *argv[])
  476. {
  477.     union REGS  regs;
  478.     struct SREGS sregs;     
  479.     unsigned far *fp;
  480.     unsigned memtop;
  481.     unsigned dummy;
  482.  
  483.     InitInDos();
  484.  
  485.     parse_cmd_line(argc,argv);
  486.  
  487.     /* check if TSR already installed! */
  488.     regs.h.ah = multiplex_id;
  489.     regs.h.al = INSTALL_CHECK;
  490.     int86(0x2f, ®s, ®s);
  491.     if (regs.h.al == INSTALLED)
  492.     {
  493.         puts("TSR already installed");
  494.         fputs(argv[0], stdout); puts(" -D de-installs");
  495.         exit(1);
  496.     }
  497.  
  498.     if (! user_key_set)
  499.     {
  500.         puts("Press ALT-D to activate TSR ");
  501.         printf("Multiplex ID = %0x \n",multiplex_id);
  502.         hot_key = HOT_KEY;
  503.         shift_key = ALT_KEY;
  504.     }
  505.    
  506. #ifdef DOS_SWAP
  507.     if (InitDosSwap() != 0)
  508.     {
  509.         puts("Error initializing DOS Swappable Data Area");
  510.         exit(1);
  511.     }
  512. #endif   
  513.  
  514.     /* MALLOC a stack for our TSR section */ 
  515.     stack_ptr = malloc(STACK_SIZE);
  516.     stack_ptr += STACK_SIZE;
  517.  
  518.     /* get interrupt vector */
  519.     old_int8  = _dos_getvect(8);     /* timer interrupt */
  520.     old_int9  = _dos_getvect(9);     /* keyboard interrupt */
  521.     old_int13 = _dos_getvect(0x13);  /* disk intr, in TSRUTIL.ASM */
  522.     old_int28 = _dos_getvect(0x28);  /* dos idle */
  523.     old_int2f = _dos_getvect(0x2f);  /* multiplex int */
  524.  
  525. #ifdef DOS_SWAP
  526.     old_int2a = _dos_getvect(0x2a);  /* dos internal int */
  527. #endif
  528.  
  529.     init_intr();  /* initilize int routines in TSRUTIL.ASM */
  530.  
  531.     /* set interrupts to our routines */
  532.     _dos_setvect(8, new_int8);
  533.     _dos_setvect(9, new_int9);
  534.     _dos_setvect(0x13, new_int13);      /* in TSRUTIL.ASM */
  535.     _dos_setvect(0x28, new_int28);
  536.     _dos_setvect(0x2f, new_int2f);
  537.  
  538. #ifdef DOS_SWAP
  539.     _dos_setvect(0x2a, new_int2a);
  540. #endif
  541.  
  542.     /* release environment back to MS-DOS */
  543.     FP_SEG(fp) = _psp;
  544.     FP_OFF(fp) = PSP_ENV_ADDR;
  545.     _dos_freemem(*fp);
  546.  
  547.     /* release unused heap to MS-DOS */
  548.     /* All MALLOCS for TSR section must be done in TSR_INIT() */
  549.     /* calculate top of memory, shrink block, and go TSR */
  550.     segread(&sregs);    
  551.     memtop = sregs.ds + PARAGRAPHS(stack_ptr) - _psp;
  552.     
  553.     _dos_setblock(memtop, _psp, &dummy);
  554.     _dos_keep(0, memtop);
  555. }
  556.