home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / W / WWIVSOR.ZIP / EXTRN.C < prev    next >
C/C++ Source or Header  |  1995-04-25  |  9KB  |  392 lines
  1. /*****************************************************************************
  2.  
  3.                 WWIV Version 4
  4.                     Copyright (C) 1988-1995 by Wayne Bell
  5.  
  6. Distribution of the source code for WWIV, in any form, modified or unmodified,
  7. without PRIOR, WRITTEN APPROVAL by the author, is expressly prohibited.
  8. Distribution of compiled versions of WWIV is limited to copies compiled BY
  9. THE AUTHOR.  Distribution of any copies of WWIV not compiled by the author
  10. is expressly prohibited.
  11.  
  12.  
  13. *****************************************************************************/
  14.  
  15.  
  16.  
  17. #include "vars.h"
  18.  
  19. #pragma hdrstop
  20.  
  21. #include <dir.h>
  22. #include <process.h>
  23. #include <math.h>
  24.  
  25.  
  26. static union REGS ca_r;
  27. static int ca_pause,ca_ctrl_c;
  28. static long ca_d1;
  29. static union REGS ni_r;
  30. static struct SREGS ni_s;
  31. static unsigned ni_n;
  32. static char ni_ch,ni_ch1;
  33. static unsigned char far *ni_st;
  34.  
  35. #define ST_SIZE 500
  36. static unsigned short ni_stack[ST_SIZE];
  37.  
  38. /****************************************************************************/
  39. /****************************************************************************/
  40. /****************************************************************************/
  41.  
  42. static unsigned char getkeyext(void)
  43. {
  44.   unsigned char ch;
  45.   static int holding=0;
  46.   static char held=0;
  47.  
  48.   if (holding) {
  49.     holding=0;
  50.     return(held);
  51.   }
  52.   ch=getkey();
  53.   if (charbufferpointer==0) {
  54.     if (ch==16) {
  55.       ch=getkey();
  56.       if ((ch==1) && (charbufferpointer==0)) {
  57.         strcpy(charbuffer,&(thisuser.macros[2][0]));
  58.         ch=charbuffer[0];
  59.         if (ch) {
  60.           charbufferpointer=1;
  61.           return(ch);
  62.         } else
  63.           return(getkeyext());
  64.       } else
  65.         if ((ch==4) && (charbufferpointer==0)) {
  66.           strcpy(charbuffer,&(thisuser.macros[0][0]));
  67.           ch=charbuffer[0];
  68.           if (ch) {
  69.             charbufferpointer=1;
  70.             return(ch);
  71.           } else
  72.             return(getkeyext());
  73.         } else
  74.           if ((ch==6) && (charbufferpointer==0)) {
  75.             strcpy(charbuffer,&(thisuser.macros[1][0]));
  76.             ch=charbuffer[0];
  77.             if (ch) {
  78.               charbufferpointer=1;
  79.               return(ch);
  80.             } else
  81.               return(getkeyext());
  82.           } else {
  83.             holding=1;
  84.             held=ch;
  85.             return(16);
  86.           }
  87.     }
  88.   }
  89.   return(ch);
  90. }
  91.  
  92. /****************************************************************************/
  93.  
  94. static void checka1(void)
  95. {
  96.   char ch;
  97.   long d1;
  98.  
  99.   while ((!empty()) && (!(abortext)) && (!hangup)) {
  100.     ch=inkey();
  101.     switch(ch) {
  102.       case 3:
  103.       case 32:
  104.       case 24:
  105.         if (eflags & EFLAG_ABORT)
  106.           abortext=1;
  107.         break;
  108.       case 'P':
  109.       case 'p':
  110.       case 19:
  111.         d1=timer1();
  112.         while ((inkey()==0) && (labs(timer1()-d1)<3276L) && (!hangup))
  113.           checkhangup();
  114.         lines_listed=0;
  115.         break;
  116.     }
  117.   }
  118. }
  119.  
  120. /****************************************************************************/
  121.  
  122. static void checka2(void)
  123. {
  124.   ca_pause=0;
  125.   ca_ctrl_c=0;
  126.   ca_r.h.ah=1;
  127.  
  128.   int86(0x16,&ca_r,&ca_r);
  129.   if ((ca_r.x.flags & 64)==0) {
  130.     if (ca_r.x.ax==11779)
  131.       ca_ctrl_c=1;
  132.     if (ca_r.x.ax==7955)
  133.       ca_pause=1;
  134.   }
  135.   if (head!=tail) {
  136.     if (buffer[tail]==3)
  137.       ca_ctrl_c=1;
  138.     if (buffer[tail]==19)
  139.       ca_pause=1;
  140.   }
  141.   if (ca_pause) {
  142.     while (inkey()!=0)
  143.       ;
  144.     ca_d1=timer1();
  145.     while ((inkey()==0) && (labs(timer1()-ca_d1)<3276L) && (!hangup))
  146.       checkhangup();
  147.     lines_listed=0;
  148.   }
  149.   if ((ca_ctrl_c) && (eflags & EFLAG_ABORT)) {
  150.     while (inkey()!=0)
  151.       ;
  152.     pl("^C");
  153.     ca_r.x.ax=0x4c00;
  154.     int86(save_dos,&ca_r,&ca_r);
  155.   }
  156. }
  157.  
  158. /****************************************************************************/
  159.  
  160. static void outdosstr(char *s)
  161. /* This function outputs a string of characters to the screen (and remotely
  162.  * if applicable).  The com port is also checked first to see if a remote
  163.  * user has hung up
  164.  */
  165. {
  166.   int i;
  167.  
  168.   checkhangup();
  169.   if (hangup==0) {
  170.     i=0;
  171.     while ((s[i] !='$') && (i<1024)) {
  172.       checka2();
  173.       outchr(s[i++]);
  174.     }
  175.   }
  176. }
  177.  
  178.  
  179.  
  180.  
  181. #pragma warn -par
  182.  
  183. void far interrupt newintr1(unsigned bp, unsigned di, unsigned si,
  184.                            unsigned ds, unsigned es, unsigned dx,
  185.                            unsigned cx, unsigned bx, unsigned ax,
  186.                            unsigned ip, unsigned cs, unsigned flags)
  187. {
  188.  
  189.   unsigned short ni_SS, ni_SP;
  190. #define NEW_STK() { _BX=FP_OFF(&ni_stack[ST_SIZE-2]); _SS=_DS; _SP=_BX; }
  191. #define OLD_STK() { _AX=ni_SS; _BX=ni_SP; _SS=_AX; _SP=_BX; }
  192.  
  193.  
  194.  
  195.   ni_r.x.ax=ax;
  196.   ni_r.x.bx=bx;
  197.   ni_r.x.cx=cx;
  198.   ni_r.x.dx=dx;
  199.   ni_r.x.si=si;
  200.   ni_r.x.di=di;
  201.   ni_r.x.flags=flags;
  202.   ni_s.ds=ds;
  203.   ni_s.es=es;
  204.  
  205.   ni_SS=_SS;
  206.   ni_SP=_SP;
  207.  
  208.   ni_ch=ni_r.h.ah;
  209.   ni_ch1=0;
  210.  
  211.   if (ni_ch==0x0c) {
  212.     dump();
  213.     switch(ni_r.h.al) {
  214.       case 0x01:
  215.       case 0x06:
  216.       case 0x07:
  217.       case 0x08:
  218.       case 0x0a:
  219.         ni_r.h.al = ni_r.h.al;
  220.         ni_ch = ni_r.h.al;
  221.         break;
  222.     }
  223.   }
  224.   switch(ni_ch) {
  225.     case 0x01:
  226.       NEW_STK();
  227.       ni_ch=getkeyext();
  228.       outchr(ni_ch);
  229.       if (hangup)
  230.         ni_ch=3;
  231.       ni_r.h.al=ni_ch;
  232.       ni_ch1=1;
  233.       OLD_STK();
  234.       break;
  235.     case 0x02:
  236.       NEW_STK();
  237.       outchr(ni_r.h.dl);
  238.       ni_ch1=1;
  239.       checka2();
  240.       OLD_STK();
  241.       break;
  242.     case 0x06:
  243.       NEW_STK();
  244.       if (ni_r.h.dl!=0xff) {
  245.         outchr(ni_r.h.dl);
  246.         ni_ch1=1;
  247.       } else {
  248.         if (empty()) {
  249.           ni_r.x.flags |= 64;
  250.         } else {
  251.           ni_r.x.flags &= (0xffff ^ 64);
  252.           ni_r.h.al=getkeyext();
  253.         }
  254.       }
  255.       OLD_STK();
  256.       break;
  257.     case 0x07:
  258.       NEW_STK();
  259.       ni_ch1=1;
  260.       ni_r.h.al=getkeyext();
  261.       OLD_STK();
  262.       break;
  263.     case 0x08:
  264.       NEW_STK();
  265.       ni_ch1=1;
  266.       ni_r.h.al=getkeyext();
  267.       OLD_STK();
  268.       break;
  269.     case 0x09:
  270.       NEW_STK();
  271.       outdosstr((char *) MK_FP(ni_s.ds, ni_r.x.dx));
  272.       ni_ch1=1;
  273.       OLD_STK();
  274.       break;
  275.     case 0x0a:
  276.       NEW_STK();
  277.       ni_st=(char *) MK_FP(ni_s.ds,ni_r.x.dx);
  278.       ni_n=(unsigned int)(ni_st[0]);
  279.       if (in_extern==2)
  280.         getkeyext();
  281.       in_extern=0;
  282.       input_extern=1;
  283.       input1(&(ni_st[2]),ni_n-3,1,0);
  284.       input_extern=0;
  285.       in_extern=1;
  286.       ni_st[1]=strlen(&(ni_st[2]));
  287.       strcat(&(ni_st[2]),"\r");
  288.       if ((hangup)) {
  289.         strcpy(&(ni_st[2]),"EXIT\r");
  290.         ni_st[1]=4;
  291.         outs("Exiting...");
  292.       }
  293.       ni_ch1=1;
  294.       OLD_STK();
  295.       break;
  296.     case 0x0b:
  297.       NEW_STK();
  298.       if (empty())
  299.         ni_r.h.al=0x00;
  300.       else
  301.         ni_r.h.al=0xff;
  302.       ni_ch1=1;
  303.       OLD_STK();
  304.       break;
  305.     case 0x0c:
  306.       break;
  307.     case 0x3f:
  308.       if (ni_r.x.bx==0x0000) {
  309.         NEW_STK();
  310.         ni_st=(char *)MK_FP(ni_s.ds,ni_r.x.dx);
  311.         inputl(ni_st,ni_r.x.cx);
  312.         strcat(ni_st,"\r\n");
  313.         ni_r.x.ax=strlen(ni_st);
  314.         if (hangup)
  315.           ni_r.x.ax=0;
  316.         ni_r.x.flags &=(0xffff ^ 1);
  317.         ni_ch1=1;
  318.         OLD_STK();
  319.       } else
  320.         int86x(save_dos,&ni_r,&ni_r,&ni_s);
  321.       break;
  322.     case 0x40:
  323.       if ((ni_r.x.bx==0x0001) || (ni_r.x.bx==0x0002)) {
  324.         NEW_STK();
  325.         ni_st=(char *)MK_FP(ni_s.ds,ni_r.x.dx);
  326.         for (ni_n=0; ni_n<ni_r.x.cx; ni_n++) {
  327.           outchr(ni_st[ni_n]);
  328.           checka2();
  329.         }
  330.         ni_r.x.ax=ni_r.x.cx;
  331.         ni_r.x.flags &=(0xffff ^ 1);
  332.         ni_ch1=1;
  333.         OLD_STK();
  334.       } else
  335.         int86x(save_dos,&ni_r,&ni_r,&ni_s);
  336.       break;
  337.     default:
  338.       int86x(save_dos,&ni_r,&ni_r,&ni_s);
  339.       break;
  340.   }
  341.  
  342.   if (ni_ch1) {
  343.     if ((eflags & EFLAG_INTERNAL) && (!abortext)) {
  344.       checka1();
  345.       if (abortext) {
  346.         ni_r.x.ax=0x4c00;
  347.         int86x(save_dos,&ni_r,&ni_r,&ni_s);
  348.       }
  349.     }
  350.     checkhangup();
  351.     if (hangup) {
  352.       if (hanguptime1<0L) {
  353.         hanguptime1=timer1();
  354.         if (funcs[20]) {
  355.           outs("Terminating...\r\n");
  356.           ip=FP_OFF(funcs[20]);
  357.           cs=FP_SEG(funcs[20]);
  358.           funcs[20]=(void far *)36;
  359.         } else {
  360.           funcs[20]=(void far *)36;
  361.           outs("Aborting...\r\n");
  362.           ni_r.x.ax=0x4c00;
  363.           int86x(save_dos,&ni_r,&ni_r,&ni_s);
  364.         }
  365.       } else {
  366.         if (((unsigned long) funcs[20])>500)
  367.           funcs[20]=(void far *)36;
  368.         if (labs(timer1()-hanguptime1)>(long)funcs[20]) {
  369.           hanguptime1=timer1();
  370.           outs("Aborting...\r\n");
  371.           ni_r.x.ax=0x4c00;
  372.           int86x(save_dos,&ni_r,&ni_r,&ni_s);
  373.         }
  374.       }
  375.     }
  376.   }
  377.  
  378.   ax=ni_r.x.ax;
  379.   bx=ni_r.x.bx;
  380.   cx=ni_r.x.cx;
  381.   dx=ni_r.x.dx;
  382.   si=ni_r.x.si;
  383.   di=ni_r.x.di;
  384.   flags=ni_r.x.flags;
  385.   ds=ni_s.ds;
  386.   es=ni_s.es;
  387. }
  388.  
  389. #pragma warn +par
  390.  
  391.  
  392.