home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / UTIL / WWIVE / MYWIVE.ZIP / EXTRN.C < prev    next >
C/C++ Source or Header  |  1993-05-06  |  13KB  |  634 lines
  1. #include "vars.h"
  2. #pragma hdrstop
  3. #include <dir.h>
  4. #include <process.h>
  5. #include <math.h>
  6. #define SCROLL_UP(t,b,l) \
  7.   _CH=t;\
  8.   _DH=b;\
  9.   _BH=curatr;\
  10.   _AL=l;\
  11.   _CL=0;\
  12.   _DL=79;\
  13.   _AH=6;\
  14.   my_video_int();
  15.  
  16. unsigned char getkeyext()
  17. {
  18.   unsigned char ch;
  19.   static int holding=0;
  20.   static char held=0;
  21.  
  22.   if (holding) {
  23.     holding=0;
  24.     return(held);
  25.   }
  26.   ch=getkey();
  27.   if (charbufferpointer==0) {
  28.     if (ch==16) {
  29.       ch=getkey();
  30.       if ((ch==1) && (charbufferpointer==0)) {
  31.         strcpy(charbuffer,&(thisuser.macros[2][0]));
  32.         ch=charbuffer[0];
  33.         if (ch) {
  34.           charbufferpointer=1;
  35.       return(ch);
  36.         } else
  37.       return(getkeyext());
  38.       } else
  39.         if ((ch==4) && (charbufferpointer==0)) {
  40.           strcpy(charbuffer,&(thisuser.macros[0][0]));
  41.           ch=charbuffer[0];
  42.           if (ch) {
  43.             charbufferpointer=1;
  44.         return(ch);
  45.           } else
  46.         return(getkeyext());
  47.         } else
  48.           if ((ch==6) && (charbufferpointer==0)) {
  49.             strcpy(charbuffer,&(thisuser.macros[1][0]));
  50.             ch=charbuffer[0];
  51.             if (ch) {
  52.               charbufferpointer=1;
  53.           return(ch);
  54.             } else
  55.           return(getkeyext());
  56.           } else {
  57.             holding=1;
  58.         held=ch;
  59.             return(16);
  60.           }
  61.     }
  62.   }
  63.   return(ch);
  64. }
  65.  
  66. void cd_to(char *s)
  67. {
  68.   char s1[81];
  69.   int i,db;
  70.  
  71.   strcpy(s1,s);
  72.   i=strlen(s1)-1;
  73.   db=(s1[i]=='\\');
  74.   if (i==0)
  75.     db=0;
  76.   if ((i==2) && (s1[1]==':'))
  77.     db=0;
  78.   if (db)
  79.     s1[i]=0;
  80.   chdir(s1);
  81.   if (s[1]==':')
  82.     setdisk(s[0]-'A');
  83. }
  84.  
  85. void get_dir(char *s, int be)
  86. {
  87.   strcpy(s,"X:\\");
  88.   s[0]='A'+getdisk();
  89.   getcurdir(0,&(s[3]));
  90.   if (be) {
  91.     if (s[strlen(s)-1]!='\\')
  92.       strcat(s,"\\");
  93.   }
  94. }
  95.  
  96. void initporte(int port_num)
  97. /* This function initializes the com buffer, setting up the interrupt,
  98.  * and com parameters
  99.  */
  100. {
  101.   int temp;
  102.  
  103.   if (!ok_modem_stuff)
  104.     return;
  105.   temp=port_num;
  106.   setvect(8+async_irq,async_isr);
  107.   head=tail=0;
  108.   outportb(base+3,0x03);
  109.   disable();
  110.   temp=inportb(base+5);
  111.   temp=inportb(base);
  112.   temp=inportb(0x21);
  113.   temp=temp & ((1 << async_irq) ^ 0x00ff);
  114.   outportb(0x21,temp);
  115.   outportb(base+1,0x01);
  116.   temp=inportb(base+4);
  117.   outportb(base+4,temp | 0x0A);
  118.   enable();
  119.   dtr(1);
  120. }
  121.  
  122. int do_it(char *cl)
  123. {
  124.   int i,i1,l;
  125.   char s[160];
  126.   char *ss[30];
  127.  
  128.   sl1(1,"");
  129.   strcpy(s,cl);
  130.   ss[0]=s;
  131.   i=1;
  132.   l=strlen(s);
  133.   for (i1=1; i1<l; i1++)
  134.     if (s[i1]==32) {
  135.       s[i1]=0;
  136.       ss[i++]=&(s[i1+1]);
  137.     }
  138.   ss[i]=NULL;
  139.   i=spawnvpe(P_WAIT,ss[0],ss,xenviron);
  140.   return(i);
  141. }
  142.  
  143. int do_remote(char *s, int ccc)
  144. {
  145.   int rc,xx;
  146.   char x[161];
  147.  
  148.   sl1(1,"");
  149.   close_user();
  150.   checkhangup();
  151.   if (hangup)
  152.     return(32767);
  153.   sprintf(x,"%s /C %s", getenv("COMSPEC"), s);
  154.   if (ccc)
  155.     rc=do_it(x);
  156.   else
  157.     rc=do_it(s);
  158.   initporte(syscfg.primaryport);
  159.   chdir(cdir);
  160.   setdisk(cdir[0]-'A');
  161.   return(rc);
  162. }
  163.  
  164. void checka1()
  165. {
  166.   char ch;
  167.   long d1;
  168.  
  169.   while ((!empty()) && (!(abortext)) && (!hangup)) {
  170.     ch=inkey();
  171.     switch(ch) {
  172.       case 3:
  173.       case 32:
  174.       case 24:
  175.         abortext=1;
  176.         break;
  177.       case 'P':
  178.       case 'p':
  179.       case 19:
  180.         d1=timer1();
  181.         while ((inkey()==0) && (labs(timer1()-d1)<3276L) && (!hangup))
  182.           checkhangup();
  183.         lines_listed=0;
  184.         break;
  185.     }
  186.   }
  187. }
  188.  
  189. union REGS ca_r;
  190. int ca_pause,ca_ctrl_c;
  191. long ca_d1;
  192.  
  193. void checka2()
  194. {
  195.   ca_pause=0;
  196.   ca_ctrl_c=0;
  197.   ca_r.h.ah=1;
  198.   int86(0x16,&ca_r,&ca_r);
  199.   if ((ca_r.x.flags & 64)==0) {
  200.     if (ca_r.x.ax==11779)
  201.       ca_ctrl_c=1;
  202.     if (ca_r.x.ax==7955)
  203.       ca_pause=1;
  204.   }
  205.   if (head!=tail) {
  206.     if (buffer[tail]==3)
  207.       ca_ctrl_c=1;
  208.     if (buffer[tail]==19)
  209.       ca_pause=1;
  210.   }
  211.   if (ca_pause) {
  212.     while (inkey()!=0);
  213.     ca_d1=timer1();
  214.     while ((inkey()==0) && (labs(timer1()-ca_d1)<3276L) && (!hangup))
  215.       checkhangup();
  216.     lines_listed=0;
  217.   }
  218.   if ((ca_ctrl_c) && (nextext)) {
  219.     while (inkey()!=0);
  220.     pl("^C");
  221.     ca_r.x.ax=0x4c00;
  222.     int86(INT_SAVE_21,&ca_r,&ca_r);
  223.   }
  224. }
  225.  
  226. void run_external(char *s)
  227. {
  228.   do_remote(s,1);
  229. }
  230.  
  231. int run_external1(char *s)
  232. {
  233.   int i;
  234.  
  235.   i=do_remote(s,0);
  236.   return(i);
  237. }
  238.  
  239. void outdosstr(char *s)
  240. /* This function outputs a string of characters to the screen (and remotely
  241.  * if applicable).  The com port is also checked first to see if a remote
  242.  * user has hung up
  243.  */
  244. {
  245.   int i;
  246.  
  247.   checkhangup();
  248.   if (hangup==0) {
  249.     i=0;
  250.     while ((s[i] !='$') && (i<1024)) {
  251.       checka2();
  252.       outchr(s[i++]);
  253.     }
  254.   }
  255. }
  256.  
  257. union REGS ni_r;
  258. struct SREGS ni_s;
  259. unsigned ni_n;
  260. char ni_ch,ni_ch1,ni_ss[10],ni_ch2;
  261. unsigned char *ni_st;
  262.  
  263. #define ST_SIZE 300
  264. static unsigned short ni_stack[ST_SIZE];
  265.  
  266. #pragma warn -par
  267.  
  268. void far interrupt newintr1(unsigned bp, unsigned di, unsigned si,
  269.                            unsigned ds, unsigned es, unsigned dx,
  270.                            unsigned cx, unsigned bx, unsigned ax,
  271.                            unsigned ip, unsigned cs, unsigned flags)
  272. {
  273.   unsigned short ni_SS, ni_SP;
  274. #define NEW_STK() { _BX=FP_OFF(&ni_stack[ST_SIZE-2]); _SS=_DS; _SP=_BX; }
  275. #define OLD_STK() { _AX=ni_SS; _BX=ni_SP; _SS=_AX; _SP=_BX; }
  276.  
  277.   ni_r.x.ax=ax;
  278.   ni_r.x.bx=bx;
  279.   ni_r.x.cx=cx;
  280.   ni_r.x.dx=dx;
  281.   ni_r.x.si=si;
  282.   ni_r.x.di=di;
  283.   ni_r.x.flags=flags;
  284.   ni_s.ds=ds;
  285.   ni_s.es=es;
  286.   ni_SS=_SS;
  287.   ni_SP=_SP;
  288.   ni_ch=ni_r.h.ah;
  289.   ni_ch1=0;
  290.   switch(ni_ch) {
  291.     case 0x01:
  292.       NEW_STK();
  293.       ni_ch=getkeyext();
  294.       outchr(ni_ch);
  295.       if (hangup)
  296.         ni_ch=3;
  297.       ni_r.h.al=ni_ch;
  298.       ni_ch1=1;
  299.       OLD_STK();
  300.       break;
  301.     case 0x02:
  302.       NEW_STK();
  303.       outchr(ni_r.h.dl);
  304.       ni_ch1=1;
  305.       checka2();
  306.       OLD_STK();
  307.       break;
  308.     case 0x06:
  309.       NEW_STK();
  310.       if (ni_r.h.dl!=0xff) {
  311.         outchr(ni_r.h.dl);
  312.         ni_ch1=1;
  313.       } else {
  314.         if (empty()) {
  315.           ni_r.x.flags |= 64;
  316.         } else {
  317.           ni_r.x.flags &= (0xffff ^ 64);
  318.           ni_r.h.al=getkeyext();
  319.         }
  320.       }
  321.       OLD_STK();
  322.       break;
  323.     case 0x07:
  324.       NEW_STK();
  325.       ni_ch1=1;
  326.       ni_r.h.al=getkeyext();
  327.       OLD_STK();
  328.       break;
  329.     case 0x08:
  330.       NEW_STK();
  331.       ni_ch1=1;
  332.       ni_r.h.al=getkeyext();
  333.       OLD_STK();
  334.       break;
  335.     case 0x09:
  336.       NEW_STK();
  337.       outdosstr((char *) MK_FP(ni_s.ds, ni_r.x.dx));
  338.       ni_ch1=1;
  339.       OLD_STK();
  340.       break;
  341.     case 0x0a:
  342.       NEW_STK();
  343.       ni_st=(char *) MK_FP(ni_s.ds,ni_r.x.dx);
  344.       ni_n=(unsigned int)(ni_st[0]);
  345.       if (in_extern==2)
  346.         getkeyext();
  347.       in_extern=0;
  348.       input_extern=1;
  349.       input1(&(ni_st[2]),ni_n-3,1,0);
  350.       input_extern=0;
  351.       in_extern=1;
  352.       ni_st[1]=strlen(&(ni_st[2]));
  353.       strcat(&(ni_st[2]),"\r");
  354.       if ((hangup)) {
  355.         strcpy(&(ni_st[2]),"EXIT\r");
  356.         ni_st[1]=4;
  357.         outs("Exiting...");
  358.       }
  359.       ni_ch1=1;
  360.       OLD_STK();
  361.       break;
  362.     case 0x0b:
  363.       NEW_STK();
  364.       if (empty())
  365.         ni_r.h.al=0x00;
  366.       else
  367.         ni_r.h.al=0xff;
  368.       ni_ch1=1;
  369.       OLD_STK();
  370.       break;
  371.     case 0x0c:
  372.       ni_r.h.ah=ni_r.h.al;
  373.       int86x(0x21,&ni_r,&ni_r,&ni_s);
  374.       ni_ch1=1;
  375.       break;
  376.     case 0x3f:
  377.       if (ni_r.x.bx==0x0000) {
  378.         NEW_STK();
  379.         ni_st=(char *)MK_FP(ni_s.ds,ni_r.x.dx);
  380.         inputl(ni_st,ni_r.x.cx);
  381.         strcat(ni_st,"\r\n");
  382.         ni_r.x.ax=strlen(ni_st);
  383.         if (hangup)
  384.           ni_r.x.ax=0;
  385.         ni_r.x.flags &=(0xffff ^ 1);
  386.         ni_ch1=1;
  387.         OLD_STK();
  388.       } else
  389.         int86x(INT_SAVE_21,&ni_r,&ni_r,&ni_s);
  390.       break;
  391.     case 0x40:
  392.       if ((ni_r.x.bx==0x0001) || (ni_r.x.bx==0x0002)) {
  393.         NEW_STK();
  394.         ni_st=(char *)MK_FP(ni_s.ds,ni_r.x.dx);
  395.         for (ni_n=0; ni_n<ni_r.x.cx; ni_n++) {
  396.           outchr(ni_st[ni_n]);
  397.           checka2();
  398.         }
  399.         ni_r.x.ax=ni_r.x.cx;
  400.         ni_r.x.flags &=(0xffff ^ 1);
  401.         ni_ch1=1;
  402.         OLD_STK();
  403.       } else
  404.         int86x(INT_SAVE_21,&ni_r,&ni_r,&ni_s);
  405.       break;
  406.     default:
  407.       int86x(INT_SAVE_21,&ni_r,&ni_r,&ni_s);
  408.       break;
  409.   }
  410.   if (ni_ch1) {
  411.     if (arcling) {
  412.       if ((nextext) && (!abortext)) {
  413.         checka1();
  414.         if (abortext) {
  415.           ni_r.x.ax=0x4c00;
  416.           int86x(INT_SAVE_21,&ni_r,&ni_r,&ni_s);
  417.         }
  418.       }
  419.     }
  420.     checkhangup();
  421.     if (hangup) {
  422.       if (hanguptime1<0L) {
  423.         hanguptime1=timer1();
  424.         outs("Aborting...\r\n");
  425.         ni_r.x.ax=0x4c00;
  426.         int86x(INT_SAVE_21,&ni_r,&ni_r,&ni_s);
  427.       } else {
  428.         if (labs(timer1()-hanguptime1)>36L) {
  429.           hanguptime1=timer1();
  430.           outs("Aborting...\r\n");
  431.           ni_r.x.ax=0x4c00;
  432.           int86x(INT_SAVE_21,&ni_r,&ni_r,&ni_s);
  433.         }
  434.       }
  435.     }
  436.   }
  437.   ax=ni_r.x.ax;
  438.   bx=ni_r.x.bx;
  439.   cx=ni_r.x.cx;
  440.   dx=ni_r.x.dx;
  441.   si=ni_r.x.si;
  442.   di=ni_r.x.di;
  443.   flags=ni_r.x.flags;
  444.   ds=ni_s.ds;
  445.   es=ni_s.es;
  446. }
  447.  
  448. #pragma warn +par
  449.  
  450. int do_external(char *s, int enab)
  451. {
  452.   unsigned short sav;
  453.  
  454.   checkhangup();
  455.   if (hangup)
  456.     return(0);
  457.   in_extern=1;
  458.   hanguptime1=-1L;
  459.   abortext=0;
  460.   nextext=enab;
  461.   arcling=1;
  462.   sav=syscfg.sysconfig;
  463.   if ((syscfg.sysconfig & sysconfig_no_local)==0)
  464.     syscfg.sysconfig |= sysconfig_no_local;
  465.   setvect(INT_SAVE_21,getvect(0x21));
  466.   set_global_handle(0);
  467.   setvect(0x21,newintr1);
  468.   do_remote(s,1);
  469.   setvect(0x21,getvect(INT_SAVE_21));
  470.   if (abortext) {
  471.     nl();
  472.     nl();
  473.   }
  474.   syscfg.sysconfig=sav;
  475.   if (in_extern==2)
  476.     getkey();
  477.   in_extern=0;
  478.   return(abortext);
  479. }
  480.  
  481. int full_external(char *s, int ctc, int ccc)
  482. {
  483.   unsigned short sav;
  484.   int ookskey,xx,cy,cx,xxx;
  485.  
  486.   sl1(1,"");
  487.   checkhangup();
  488.   if (hangup)
  489.     return(0);
  490.   in_extern=1;
  491.   ookskey=okskey;
  492.   okskey=0;
  493.   hanguptime1=-1L;
  494.   arcling=0;
  495.   if (screenlinest>defscreenbottom-topline)
  496.     set_protect(0);
  497.   abortext=0;
  498.   nextext=ctc;
  499.   sav=syscfg.sysconfig;
  500.   if ((syscfg.sysconfig & sysconfig_no_local)==0)
  501.     syscfg.sysconfig |= sysconfig_no_local;
  502.   setvect(INT_SAVE_21,getvect(0x21));
  503.   set_global_handle(0);
  504.   setvect(0x21,newintr1);
  505.   if ((screenlinest<=defscreenbottom) && (screenlinest>20)) {
  506.     screenbottom=screenlinest-1+topline;
  507.     cy=wherey();
  508.     cx=wherex();
  509.     xxx=cy-screenbottom+topline;
  510.     if (xxx>0) {
  511.       SCROLL_UP(topline,defscreenbottom,xxx);
  512.       movecsr(cx,screenbottom);
  513.     }
  514.   }
  515.   do_remote(s,ccc);
  516.   screenbottom=defscreenbottom;
  517.   setvect(0x21,getvect(INT_SAVE_21));
  518.   if (abortext) {
  519.     nl();
  520.     nl();
  521.   }
  522.   syscfg.sysconfig=sav;
  523.   okskey=ookskey;
  524.   if (in_extern==2)
  525.     getkey();
  526.   in_extern=0;
  527.   if (!wfc)
  528.     topscreen();
  529.   return(abortext);
  530. }
  531.  
  532. void alf(int f, char *s)
  533. {
  534.   char s1[100];
  535.  
  536.   strcpy(s1,s);
  537.   strcat(s1,"\r\n");
  538.   write(f,(void *)s1,strlen(s1));
  539. }
  540.  
  541. char *create_chain_file(char *fn)
  542. {
  543.   int i,i1,f;
  544.   char s[81],s1[81],gd[81],dd[81];
  545.   static char fpn[81];
  546.   long l;
  547.  
  548.   cd_to(syscfg.gfilesdir);
  549.   get_dir(gd,1);
  550.   cd_to(cdir);
  551.   cd_to(syscfg.datadir);
  552.   get_dir(dd,1);
  553.   cd_to(cdir);
  554.   unlink(fn);
  555.   f=open(fn,O_RDWR | O_CREAT | O_BINARY, S_IREAD | S_IWRITE);
  556.   itoa(usernum,s,10);
  557.   alf(f,s);
  558.   alf(f,thisuser.name);
  559.   alf(f,thisuser.realname);
  560.   alf(f,thisuser.zipcode);
  561.   itoa(thisuser.age,s,10);
  562.   alf(f,s);
  563.   s[0]=thisuser.sex;
  564.   s[1]=0;
  565.   alf(f,s);
  566.   sprintf(s,"%10.2f",thisuser.gold);
  567.   alf(f,s);
  568.   alf(f,thisuser.laston);
  569.   itoa(thisuser.screenchars,s,10);
  570.   alf(f,s);
  571.   itoa(thisuser.screenlines,s,10);
  572.   alf(f,s);
  573.   itoa(thisuser.sl,s,10);
  574.   alf(f,s);
  575.   if (cs())
  576.     alf(f,"1");
  577.   else
  578.     alf(f,"0");
  579.   if (so())
  580.     alf(f,"1");
  581.   else
  582.     alf(f,"0");
  583.   if (okansi())
  584.     alf(f,"1");
  585.   else
  586.     alf(f,"0");
  587.   if (incom)
  588.     alf(f,"1");
  589.   else
  590.     alf(f,"0");
  591.   sprintf(s,"%10.2f",nsl());
  592.   alf(f,s);
  593.   alf(f,gd);
  594.   alf(f,dd);
  595.   sl1(3,s);
  596.   alf(f,s);
  597.   sprintf(s,"%u",modem_speed);
  598.   if (!using_modem)
  599.     strcpy(s,"KB");
  600.   alf(f,s);
  601.   itoa(syscfg.primaryport,s,10);
  602.   alf(f,s);
  603.   alf(f,syscfg.systemname);
  604.   alf(f,syscfg.sysopname);
  605.   l=(long) (timeon);
  606.   if (l<0)
  607.     l += 3600*24;
  608.   ltoa(l,s,10);
  609.   alf(f,s);
  610.   l=(long) (timer()-timeon);
  611.   if (l<0)
  612.     l += 3600*24;
  613.   ltoa(l,s,10);
  614.   alf(f,s);
  615.   ltoa(thisuser.uk,s,10);
  616.   alf(f,s);
  617.   itoa(thisuser.uploaded,s,10);
  618.   alf(f,s);
  619.   ltoa(thisuser.dk,s,10);
  620.   alf(f,s);
  621.   itoa(thisuser.downloaded,s,10);
  622.   alf(f,s);
  623.   if (andwith==0x7f)
  624.     alf(f,"7E1");
  625.   else
  626.     alf(f,"8N1");
  627.   sprintf(s,"%u",com_speed);
  628.   alf(f,s);
  629.   close(f);
  630.   get_dir(fpn,1);
  631.   strcat(fpn,fn);
  632.   return(fpn);
  633. }
  634.