home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 September / PCO_0998.ISO / filesbbs / dos / sbbs_src.exe / SBBS / EXECMISC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-13  |  35.6 KB  |  1,374 lines
  1. #line 1 "EXECMISC.C"
  2.  
  3. /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
  4.  
  5. #include "sbbs.h"
  6. #include "cmdshell.h"
  7. #include <sys/locking.h>
  8. #include <dirent.h>
  9.  
  10.  
  11. int exec_misc(csi_t *csi, uchar *path)
  12. {
  13.     uchar    str[256],tmp2[128],buf[1025],ch,*p,**pp,**pp1,**pp2;
  14.     ushort    w;
  15.     int     i,j,k,s,file;
  16.     long    l,*lp,*lp1,*lp2;
  17.     void    *vp;
  18.     va_list arglist[64];
  19.     struct    dirent *de;
  20.     struct  tm *tm_p;
  21.     struct    ftime ft;
  22.     FILE    *fp;
  23.  
  24. switch(*(csi->ip++)) {
  25.     case CS_VAR_INSTRUCTION:
  26.         switch(*(csi->ip++)) {    /* sub-op-code stored as next byte */
  27.             case PRINT_VAR:
  28.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  29.                 if(!pp || !*pp) {
  30.                     lp=getintvar(csi,*(long *)csi->ip);
  31.                     if(lp)
  32.                         bprintf("%ld",*lp); }
  33.                 else
  34.                     putmsg(cmdstr(*pp,path,csi->str,buf)
  35.                         ,P_SAVEATR|P_NOABORT);
  36.                 csi->ip+=4;
  37.                 return(0);
  38.             case VAR_PRINTF:
  39.                 strcpy(str,csi->ip);
  40.                 while(*(csi->ip++));    /* Find NULL */
  41.                 j=*(csi->ip++);         /* total args */
  42.                 for(i=0;i<j;i++) {
  43.                     vp=getstrvar(csi,*(long *)csi->ip);
  44.                     if(!vp) {
  45.                         lp=getintvar(csi,*(long *)csi->ip);
  46.                         if(!lp)
  47.                             arglist[i]=0;
  48.                         else
  49.                             arglist[i]=(void *)*lp; }
  50.                     else
  51.                         arglist[i]=*(char **)vp;
  52.                     csi->ip+=4; }
  53.                 vsprintf(tmp,str,arglist);
  54.                 putmsg(cmdstr(tmp,path,csi->str,buf),P_SAVEATR|P_NOABORT);
  55.                 return(0);
  56.             case SHOW_VARS:
  57.                 bprintf("shell     str=(%08lX) %s\r\n"
  58.                     ,csi->str,csi->str);
  59.                 for(i=0;i<csi->str_vars;i++)
  60.                     bprintf("local  str[%d]=(%08lX) (%08lX) %s\r\n"
  61.                         ,i,csi->str_var_name[i]
  62.                         ,csi->str_var[i]
  63.                         ,csi->str_var[i]);
  64.                 for(i=0;i<csi->int_vars;i++)
  65.                     bprintf("local  int[%d]=(%08lX) (%08lX) %ld\r\n"
  66.                         ,i,csi->int_var_name[i]
  67.                         ,csi->int_var[i]
  68.                         ,csi->int_var[i]);
  69.                 for(i=0;i<global_str_vars;i++)
  70.                     bprintf("global str[%d]=(%08lX) (%08lX) %s\r\n"
  71.                         ,i,global_str_var_name[i]
  72.                         ,global_str_var[i]
  73.                         ,global_str_var[i]);
  74.                 for(i=0;i<global_int_vars;i++)
  75.                     bprintf("global int[%d]=(%08lX) (%08lX) %ld\r\n"
  76.                         ,i,global_int_var_name[i]
  77.                         ,global_int_var[i]
  78.                         ,global_int_var[i]);
  79.                 return(0);
  80.             case DEFINE_STR_VAR:
  81.                 if(getstrvar(csi,*(long *)csi->ip)) {
  82.                     csi->ip+=4;
  83.                     return(0); }
  84.                 csi->str_vars++;
  85.                 csi->str_var=REALLOC(csi->str_var
  86.                     ,sizeof(char *)*csi->str_vars);
  87.                 csi->str_var_name=REALLOC(csi->str_var_name
  88.                     ,sizeof(long)*csi->str_vars);
  89.                 if(csi->str_var==NULL
  90.                     || csi->str_var_name==NULL) { /* REALLOC failed */
  91.                     errormsg(WHERE,ERR_ALLOC,"local str var"
  92.                         ,sizeof(char *)*csi->str_vars);
  93.                     if(csi->str_var_name) {
  94.                         FREE(csi->str_var_name);
  95.                         csi->str_var_name=0; }
  96.                     if(csi->str_var) {
  97.                         FREE(csi->str_var);
  98.                         csi->str_var=0; }
  99.                     csi->str_vars=0; }
  100.                 else {
  101.                     csi->str_var_name[csi->str_vars-1]=*(long *)csi->ip;
  102.                     csi->str_var[csi->str_vars-1]=0; }
  103.                 csi->ip+=4; /* Skip variable name */
  104.                 return(0);
  105.             case DEFINE_INT_VAR:
  106.                 if(getintvar(csi,*(long *)csi->ip)) {
  107.                     csi->ip+=4;
  108.                     return(0); }
  109.                 csi->int_vars++;
  110.                 csi->int_var=REALLOC(csi->int_var
  111.                     ,sizeof(char *)*csi->int_vars);
  112.                 csi->int_var_name=REALLOC(csi->int_var_name
  113.                     ,sizeof(long)*csi->int_vars);
  114.                 if(csi->int_var==NULL
  115.                     || csi->int_var_name==NULL) { /* REALLOC failed */
  116.                     errormsg(WHERE,ERR_ALLOC,"local int var"
  117.                         ,sizeof(char *)*csi->int_vars);
  118.                     if(csi->int_var_name) {
  119.                         FREE(csi->int_var_name);
  120.                         csi->int_var_name=0; }
  121.                     if(csi->int_var) {
  122.                         FREE(csi->int_var);
  123.                         csi->int_var=0; }
  124.                     csi->int_vars=0; }
  125.                 else {
  126.                     csi->int_var_name[csi->int_vars-1]=*(long *)csi->ip;
  127.                     csi->int_var[csi->int_vars-1]=0; }
  128.                 csi->ip+=4; /* Skip variable name */
  129.                 return(0);
  130.             case DEFINE_GLOBAL_STR_VAR:
  131.                 if(getstrvar(csi,*(long *)csi->ip)) {
  132.                     csi->ip+=4;
  133.                     return(0); }
  134.                 global_str_vars++;
  135.                 global_str_var=REALLOC(global_str_var
  136.                     ,sizeof(char *)*global_str_vars);
  137.                 global_str_var_name=REALLOC(global_str_var_name
  138.                     ,sizeof(long)*global_str_vars);
  139.                 if(global_str_var==NULL
  140.                     || global_str_var_name==NULL) { /* REALLOC failed */
  141.                     errormsg(WHERE,ERR_ALLOC,"global str var"
  142.                         ,sizeof(char *)*global_str_vars);
  143.                     if(global_str_var_name) {
  144.                         FREE(global_str_var_name);
  145.                         global_str_var_name=0; }
  146.                     if(global_str_var) {
  147.                         FREE(global_str_var);
  148.                         global_str_var=0; }
  149.                     global_str_vars=0; }
  150.                 else {
  151.                     global_str_var_name[global_str_vars-1]=
  152.                         *(long *)csi->ip;
  153.                     global_str_var[global_str_vars-1]=0; }
  154.                 csi->ip+=4; /* Skip variable name */
  155.                 return(0);
  156.             case DEFINE_GLOBAL_INT_VAR:
  157.                 if(getintvar(csi,*(long *)csi->ip)) {
  158.                     csi->ip+=4;
  159.                     return(0); }
  160.                 global_int_vars++;
  161.                 global_int_var=REALLOC(global_int_var
  162.                     ,sizeof(char *)*global_int_vars);
  163.                 global_int_var_name=REALLOC(global_int_var_name
  164.                     ,sizeof(long)*global_int_vars);
  165.                 if(global_int_var==NULL
  166.                     || global_int_var_name==NULL) { /* REALLOC failed */
  167.                     errormsg(WHERE,ERR_ALLOC,"local int var"
  168.                         ,sizeof(char *)*global_int_vars);
  169.                     if(global_int_var_name) {
  170.                         FREE(global_int_var_name);
  171.                         global_int_var_name=0; }
  172.                     if(global_int_var) {
  173.                         FREE(global_int_var);
  174.                         global_int_var=0; }
  175.                     global_int_vars=0; }
  176.                 else {
  177.                     global_int_var_name[global_int_vars-1]
  178.                         =*(long *)csi->ip;
  179.                     global_int_var[global_int_vars-1]=0; }
  180.                 csi->ip+=4; /* Skip variable name */
  181.                 return(0);
  182.  
  183.             case SET_STR_VAR:
  184.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  185.                 csi->ip+=4; /* Skip variable name */
  186.                 if(pp)
  187.                     *pp=copystrvar(csi,*pp
  188.                         ,cmdstr(csi->ip,path,csi->str,buf));
  189.                 while(*(csi->ip++));     /* Find NULL */
  190.                 return(0);
  191.             case SET_INT_VAR:
  192.                 lp=getintvar(csi,*(long *)csi->ip);
  193.                 csi->ip+=4; /* Skip variable name */
  194.                 if(lp)
  195.                     *lp=*(long *)csi->ip;
  196.                 csi->ip+=4; /* Skip value */
  197.                 return(0);
  198.             case COMPARE_STR_VAR:
  199.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  200.                 csi->ip+=4; /* Skip variable name */
  201.                 if(pp)
  202.                     csi->logic=stricmp(*pp
  203.                         ,cmdstr(csi->ip,path,csi->str,buf));
  204.                 else {    /* Uninitialized str var */
  205.                     if(*(csi->ip)==0)     /* Blank static str */
  206.                         csi->logic=LOGIC_TRUE;
  207.                     else
  208.                         csi->logic=LOGIC_FALSE; }
  209.                 while(*(csi->ip++));     /* Find NULL */
  210.                 return(0);
  211.             case STRSTR_VAR:
  212.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  213.                 csi->ip+=4; /* Skip variable name */
  214.                 if(pp && *pp && strstr(*pp
  215.                     ,cmdstr(csi->ip,path,csi->str,buf)))
  216.                     csi->logic=LOGIC_TRUE;
  217.                 else
  218.                     csi->logic=LOGIC_FALSE;
  219.                 while(*(csi->ip++));     /* Find NULL */
  220.                 return(0);
  221.             case STRNCMP_VAR:
  222.                 i=*csi->ip++;
  223.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  224.                 csi->ip+=4; /* Skip variable name */
  225.                 if(pp && *pp)
  226.                     csi->logic=strnicmp(*pp
  227.                         ,cmdstr(csi->ip,path,csi->str,buf),i);
  228.                 else
  229.                     csi->logic=LOGIC_FALSE;
  230.                 while(*(csi->ip++));     /* Find NULL */
  231.                 return(0);
  232.             case STRNCMP_VARS:
  233.                 i=*csi->ip++;
  234.                 (char **)pp1=getstrvar(csi,*(long *)csi->ip);
  235.                 csi->ip+=4; /* Skip variable name */
  236.                 (char **)pp2=getstrvar(csi,*(long *)csi->ip);
  237.                 csi->ip+=4;
  238.                 if(pp1 && *pp1 && pp2 && *pp2)
  239.                     csi->logic=strnicmp(*pp1,*pp2,i);
  240.                 else
  241.                     csi->logic=LOGIC_FALSE;
  242.                 return(0);
  243.             case STRSTR_VARS:
  244.                 (char **)pp1=getstrvar(csi,*(long *)csi->ip);
  245.                 csi->ip+=4; /* Skip variable name */
  246.                 (char **)pp2=getstrvar(csi,*(long *)csi->ip);
  247.                 csi->ip+=4;
  248.                 if(pp1 && *pp1 && pp2 && *pp2 && strstr(*pp1,*pp2))
  249.                     csi->logic=LOGIC_TRUE;
  250.                 else
  251.                     csi->logic=LOGIC_FALSE;
  252.                 return(0);
  253.             case COMPARE_INT_VAR:
  254.                 lp=getintvar(csi,*(long *)csi->ip);
  255.                 csi->ip+=4; /* Skip variable name */
  256.                 l=*(long *)csi->ip;
  257.                 csi->ip+=4; /* Skip static value */
  258.                 if(!lp) {    /* Unknown variable */
  259.                     csi->logic=LOGIC_FALSE;
  260.                     return(0); }
  261.                 if(*lp>l)
  262.                     csi->logic=LOGIC_GREATER;
  263.                 else if(*lp<l)
  264.                     csi->logic=LOGIC_LESS;
  265.                 else
  266.                     csi->logic=LOGIC_EQUAL;
  267.                 return(0);
  268.             case COMPARE_VARS:
  269.                 lp1=lp2=0;
  270.                 (char **)pp1=getstrvar(csi,*(long *)csi->ip);
  271.                 if(!pp1)
  272.                     lp1=getintvar(csi,*(long *)csi->ip);
  273.                 csi->ip+=4; /* Skip variable name */
  274.                 (char **)pp2=getstrvar(csi,*(long *)csi->ip);
  275.                 if(!pp2)
  276.                     lp2=getintvar(csi,*(long *)csi->ip);
  277.                 csi->ip+=4; /* Skip variable name */
  278.  
  279.                 if(((!pp1 || !*pp1) && !lp1)
  280.                     || ((!pp2 || !*pp2) && !lp2)) {
  281.                     if(pp1 && pp2)        /* Both unitialized or blank */
  282.                         csi->logic=LOGIC_TRUE;
  283.                     else
  284.                         csi->logic=LOGIC_FALSE;
  285.                     return(0); }
  286.  
  287.                 if(pp1) { /* ASCII */
  288.                     if(!pp2) {
  289.                         ltoa(*lp2,tmp,10);
  290.                         csi->logic=stricmp(*pp1,tmp); }
  291.                     else
  292.                         csi->logic=stricmp(*pp1,*pp2);
  293.                     return(0); }
  294.  
  295.                 /* Binary */
  296.                 if(!lp2) {
  297.                     l=strtol(*pp2,0,0);
  298.                     if(*lp1>l)
  299.                         csi->logic=LOGIC_GREATER;
  300.                     else if(*lp1<l)
  301.                         csi->logic=LOGIC_LESS;
  302.                     else
  303.                         csi->logic=LOGIC_EQUAL;
  304.                     return(0); }
  305.                 if(*lp1>*lp2)
  306.                     csi->logic=LOGIC_GREATER;
  307.                 else if(*lp1<*lp2)
  308.                     csi->logic=LOGIC_LESS;
  309.                 else
  310.                     csi->logic=LOGIC_EQUAL;
  311.                 return(0);
  312.             case COPY_VAR:
  313.                 lp1=lp2=0;
  314.                 (char **)pp1=getstrvar(csi,*(long *)csi->ip);
  315.                 if(!pp1)
  316.                     lp1=getintvar(csi,*(long *)csi->ip);
  317.                 csi->ip+=4; /* Skip variable name */
  318.                 (char **)pp2=getstrvar(csi,*(long *)csi->ip);
  319.                 if(!pp2)
  320.                     lp2=getintvar(csi,*(long *)csi->ip);
  321.                 csi->ip+=4; /* Skip variable name */
  322.  
  323.                 if((!pp1 && !lp1)
  324.                     || ((!pp2 || !*pp2) && !lp2)) {
  325.                     csi->logic=LOGIC_FALSE;
  326.                     return(0); }
  327.                 csi->logic=LOGIC_TRUE;
  328.  
  329.                 if(pp1) {    /* ASCII */
  330.                     if(!pp2)
  331.                         ltoa(*lp2,tmp,10);
  332.                     else
  333.                         strcpy(tmp,*pp2);
  334.                     *pp1=copystrvar(csi,*pp1,tmp);
  335.                     return(0); }
  336.                 if(!lp2)
  337.                     *lp1=strtol(*pp2,0,0);
  338.                 else
  339.                     *lp1=*lp2;
  340.                 return(0);
  341.             case SWAP_VARS:
  342.                 lp1=lp2=0;
  343.                 (char **)pp1=getstrvar(csi,*(long *)csi->ip);
  344.                 if(!pp1)
  345.                     lp1=getintvar(csi,*(long *)csi->ip);
  346.                 csi->ip+=4; /* Skip variable name */
  347.                 (char **)pp2=getstrvar(csi,*(long *)csi->ip);
  348.                 if(!pp2)
  349.                     lp2=getintvar(csi,*(long *)csi->ip);
  350.                 csi->ip+=4; /* Skip variable name */
  351.  
  352.                 if(((!pp1 || !*pp1) && !lp1)
  353.                     || ((!pp2 || !*pp2) && !lp2)) {
  354.                     csi->logic=LOGIC_FALSE;
  355.                     return(0); }
  356.  
  357.                 csi->logic=LOGIC_TRUE;
  358.  
  359.                 if(pp1) {    /* ASCII */
  360.                     if(!pp2) {
  361.                         if(!strnicmp(*pp2,"0x",2)) {
  362.                             l=strtol((*pp1)+2,0,16);
  363.                             ltoa(*lp2,tmp,16); }
  364.                         else {
  365.                             l=atol(*pp1);
  366.                             ltoa(*lp2,tmp,10); }
  367.                         *pp1=copystrvar(csi,*pp1,tmp);
  368.                         *lp2=l; }
  369.                     else {
  370.                         p=*pp1;
  371.                         *pp1=*pp2;
  372.                         *pp2=p; }
  373.                     return(0); }
  374.  
  375.                 /* Binary */
  376.                 if(!lp2) {
  377.                     if(!strnicmp(*pp2,"0x",2)) {
  378.                         l=strtol((*pp2)+2,0,16);
  379.                         ltoa(*lp1,tmp,16); }
  380.                     else {
  381.                         l=atol(*pp2);
  382.                         ltoa(*lp1,tmp,10); }
  383.                     *pp2=copystrvar(csi,*pp2,tmp);
  384.                     *lp1=l; }
  385.                 else {
  386.                     l=*lp1;
  387.                     *lp1=*lp2;
  388.                     *lp2=l; }
  389.                 return(0);
  390.             case CAT_STR_VAR:
  391.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  392.                 csi->ip+=4; /* Skip variable name */
  393.                 strcpy(tmp,csi->ip);
  394.                 while(*(csi->ip++));
  395.                 if(pp && *pp)
  396.                     for(i=0;i<MAX_SYSVARS;i++)
  397.                         if(*pp==sysvar_p[i])
  398.                             break;
  399.                 if(pp && *pp!=csi->str && i==MAX_SYSVARS) {
  400.                     if(*pp)
  401.                         *pp=REALLOC(*pp,strlen(*pp)+strlen(tmp)+1);
  402.                     else
  403.                         *pp=REALLOC(*pp,strlen(tmp)+1); }
  404.                 if(pp && *pp)
  405.                     strcat(*pp,tmp);
  406.                 return(0);
  407.             case CAT_STR_VARS:
  408.                 (char **)pp1=getstrvar(csi,*(long *)csi->ip);
  409.                 csi->ip+=4; /* Skip dest variable name */
  410.                 (char **)pp2=getstrvar(csi,*(long *)csi->ip);
  411.                 csi->ip+=4; /* Skip source variable name */
  412.                 if(!pp1 || !pp2 || !*pp2) {
  413.                     csi->logic=LOGIC_FALSE;
  414.                     return(0); }
  415.                 csi->logic=LOGIC_TRUE;
  416.                 if(*pp1)
  417.                     for(i=0;i<MAX_SYSVARS;i++)
  418.                         if(*pp1==sysvar_p[i])
  419.                             break;
  420.                 if(*pp1!=csi->str && (!*pp1 || i==MAX_SYSVARS)) {
  421.                     if(*pp1)
  422.                         *pp1=REALLOC(*pp1,strlen(*pp1)+strlen(*pp2)+1);
  423.                     else
  424.                         *pp1=REALLOC(*pp1,strlen(*pp2)+1); }
  425.                 strcat(*pp1,*pp2);
  426.                 return(0);
  427.             case FORMAT_STR_VAR:
  428.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  429.                 csi->ip+=4; /* Skip variable name */
  430.                 strcpy(str,csi->ip);
  431.                 while(*(csi->ip++));    /* Find NULL */
  432.                 j=*(csi->ip++);         /* total args */
  433.                 for(i=0;i<j;i++) {
  434.                     vp=getstrvar(csi,*(long *)csi->ip);
  435.                     if(!vp) {
  436.                         lp=getintvar(csi,*(long *)csi->ip);
  437.                         if(!lp)
  438.                             arglist[i]=0;
  439.                         else
  440.                             arglist[i]=(void *)*lp; }
  441.                     else
  442.                         arglist[i]=*(char **)vp;
  443.                     csi->ip+=4; }
  444.                 vsprintf(tmp,str,arglist);
  445.                 cmdstr(tmp,path,csi->str,str);
  446.                 if(pp)
  447.                     *pp=copystrvar(csi,*pp,str);
  448.                 return(0);
  449.             case FORMAT_TIME_STR:
  450.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  451.                 csi->ip+=4; /* Skip variable name */
  452.                 strcpy(str,csi->ip);
  453.                 while(*(csi->ip++));    /* Find NULL */
  454.                 lp=getintvar(csi,*(long *)csi->ip);
  455.                 csi->ip+=4;
  456.                 if(pp && lp) {
  457.                     tm_p=gmtime(lp);
  458.                     strftime(buf,128,str,tm_p);
  459.                     *pp=copystrvar(csi,*pp,buf); }
  460.                 return(0);
  461.             case TIME_STR:
  462.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  463.                 csi->ip+=4; /* Skip str variable name */
  464.                 lp=getintvar(csi,*(long *)csi->ip);
  465.                 csi->ip+=4; /* Skip int variable name */
  466.                 if(pp && lp) {
  467.                     strcpy(str,timestr(lp));
  468.                     *pp=copystrvar(csi,*pp,str); }
  469.                 return(0);
  470.             case DATE_STR:
  471.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  472.                 csi->ip+=4; /* Skip str variable name */
  473.                 lp=getintvar(csi,*(long *)csi->ip);
  474.                 csi->ip+=4; /* Skip int variable name */
  475.                 if(pp && lp) {
  476.                     unixtodstr(*lp,str);
  477.                     *pp=copystrvar(csi,*pp,str); }
  478.                 return(0);
  479.             case SECOND_STR:
  480.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  481.                 csi->ip+=4; /* Skip str variable name */
  482.                 lp=getintvar(csi,*(long *)csi->ip);
  483.                 csi->ip+=4; /* Skip int variable name */
  484.                 if(pp && lp) {
  485.                     sectostr(*lp,str);
  486.                     *pp=copystrvar(csi,*pp,str); }
  487.                 return(0);
  488.             case STRUPR_VAR:
  489.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  490.                 csi->ip+=4;
  491.                 if(pp && *pp)
  492.                     strupr(*pp);
  493.                 return(0);
  494.             case STRLWR_VAR:
  495.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  496.                 csi->ip+=4;
  497.                 if(pp && *pp)
  498.                     strlwr(*pp);
  499.                 return(0);
  500.             case TRUNCSP_STR_VAR:
  501.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  502.                 csi->ip+=4;
  503.                 if(pp && *pp)
  504.                     truncsp(*pp);
  505.                 return(0);
  506.             case STRIP_CTRL_STR_VAR:
  507.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  508.                 csi->ip+=4;
  509.                 if(pp && *pp)
  510.                     strip_ctrl(*pp);
  511.                 return(0);
  512.  
  513.             case ADD_INT_VAR:
  514.             case SUB_INT_VAR:
  515.             case MUL_INT_VAR:
  516.             case DIV_INT_VAR:
  517.             case MOD_INT_VAR:
  518.             case AND_INT_VAR:
  519.             case OR_INT_VAR:
  520.             case NOT_INT_VAR:
  521.             case XOR_INT_VAR:
  522.                 i=*(csi->ip-1);
  523.                 lp=getintvar(csi,*(long *)csi->ip);
  524.                 csi->ip+=4;
  525.                 l=*(long *)csi->ip;
  526.                 csi->ip+=4;
  527.                 if(!lp)
  528.                     return(0);
  529.                 switch(i) {
  530.                     case ADD_INT_VAR:
  531.                         *lp+=l;
  532.                         break;
  533.                     case SUB_INT_VAR:
  534.                         *lp-=l;
  535.                         break;
  536.                     case MUL_INT_VAR:
  537.                         *lp*=l;
  538.                         break;
  539.                     case DIV_INT_VAR:
  540.                         *lp/=l;
  541.                         break;
  542.                     case MOD_INT_VAR:
  543.                         *lp%=l;
  544.                         break;
  545.                     case AND_INT_VAR:
  546.                         *lp&=l;
  547.                         break;
  548.                     case OR_INT_VAR:
  549.                         *lp|=l;
  550.                         break;
  551.                     case NOT_INT_VAR:
  552.                         *lp&=~l;
  553.                         break;
  554.                     case XOR_INT_VAR:
  555.                         *lp^=l;
  556.                         break; }
  557.                 return(0);
  558.             case ADD_INT_VARS:
  559.             case SUB_INT_VARS:
  560.             case MUL_INT_VARS:
  561.             case DIV_INT_VARS:
  562.             case MOD_INT_VARS:
  563.             case AND_INT_VARS:
  564.             case OR_INT_VARS:
  565.             case NOT_INT_VARS:
  566.             case XOR_INT_VARS:
  567.                 i=*(csi->ip-1);
  568.                 lp1=getintvar(csi,*(long *)csi->ip);
  569.                 csi->ip+=4;
  570.                 lp2=getintvar(csi,*(long *)csi->ip);
  571.                 csi->ip+=4;
  572.                 if(!lp1)
  573.                     return(0);
  574.                 if(!lp2) {
  575.                     (char **)pp=getstrvar(csi,*(long *)csi->ip);
  576.                     if(!pp || !*pp)
  577.                         return(0);
  578.                     l=strtol(*pp,0,0); }
  579.                 else
  580.                     l=*lp2;
  581.                 switch(i) {
  582.                     case ADD_INT_VARS:
  583.                         *lp1+=l;
  584.                         break;
  585.                     case SUB_INT_VARS:
  586.                         *lp1-=l;
  587.                         break;
  588.                     case MUL_INT_VARS:
  589.                         *lp1*=l;
  590.                         break;
  591.                     case DIV_INT_VARS:
  592.                         *lp1/=l;
  593.                         break;
  594.                     case MOD_INT_VARS:
  595.                         *lp1%=l;
  596.                         break;
  597.                     case AND_INT_VARS:
  598.                         *lp1&=l;
  599.                         break;
  600.                     case OR_INT_VARS:
  601.                         *lp1|=l;
  602.                         break;
  603.                     case NOT_INT_VARS:
  604.                         *lp1&=~l;
  605.                         break;
  606.                     case XOR_INT_VARS:
  607.                         *lp1^=l;
  608.                         break; }
  609.                 return(0);
  610.             case RANDOM_INT_VAR:
  611.                 lp=getintvar(csi,*(long *)csi->ip);
  612.                 csi->ip+=4;
  613.                 l=*(long *)csi->ip;
  614.                 csi->ip+=4;
  615.                 if(lp)
  616.                     *lp=random(l);
  617.                 return(0);
  618.             case TIME_INT_VAR:
  619.                 lp=getintvar(csi,*(long *)csi->ip);
  620.                 csi->ip+=4;
  621.                 if(lp)
  622.                     *lp=time(NULL);
  623.                 return(0);
  624.             case DATE_STR_TO_INT:
  625.                 lp=getintvar(csi,*(long *)csi->ip);
  626.                 csi->ip+=4;
  627.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  628.                 csi->ip+=4;
  629.                 if(lp && pp && *pp)
  630.                     *lp=dstrtounix(*pp);
  631.                 return(0);
  632.             case STRLEN_INT_VAR:
  633.                 lp=getintvar(csi,*(long *)csi->ip);
  634.                 csi->ip+=4;
  635.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  636.                 csi->ip+=4;
  637.                 if(lp) {
  638.                     if(pp && *pp)
  639.                         *lp=strlen(*pp);
  640.                     else
  641.                         *lp=0; }
  642.                 return(0);
  643.             case CRC16_TO_INT:
  644.                 lp=getintvar(csi,*(long *)csi->ip);
  645.                 csi->ip+=4;
  646.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  647.                 csi->ip+=4;
  648.                 if(lp) {
  649.                     if(pp && *pp)
  650.                         *lp=crc16(*pp);
  651.                     else
  652.                         *lp=0; }
  653.                 return(0);
  654.             case CRC32_TO_INT:
  655.                 lp=getintvar(csi,*(long *)csi->ip);
  656.                 csi->ip+=4;
  657.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  658.                 csi->ip+=4;
  659.                 if(lp) {
  660.                     if(pp && *pp)
  661.                         *lp=crc32(*pp,strlen(*pp));
  662.                     else
  663.                         *lp=0; }
  664.                 return(0);
  665.             case CHKSUM_TO_INT:
  666.                 lp=getintvar(csi,*(long *)csi->ip);
  667.                 csi->ip+=4;
  668.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  669.                 csi->ip+=4;
  670.                 if(lp) {
  671.                     *lp=0;
  672.                     if(pp && *pp) {
  673.                         i=0;
  674.                         while(*((*pp)+i))
  675.                             *lp+=(uchar)*((*pp)+(i++)); } }
  676.                 return(0);
  677.             case FLENGTH_TO_INT:
  678.                 lp=getintvar(csi,*(long *)csi->ip);
  679.                 csi->ip+=4;
  680.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  681.                 csi->ip+=4;
  682.                 if(lp) {
  683.                     if(pp && *pp)
  684.                         *lp=flength(*pp);
  685.                     else
  686.                         *lp=0; }
  687.                 return(0);
  688.             case FTIME_TO_INT:
  689.                 lp=getintvar(csi,*(long *)csi->ip);
  690.                 csi->ip+=4;
  691.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  692.                 csi->ip+=4;
  693.                 if(lp) {
  694.                     if(pp && *pp)
  695.                         *lp=fdate_dir(*pp);
  696.                     else
  697.                         *lp=0; }
  698.                 return(0);
  699.             case CHARVAL_TO_INT:
  700.                 lp=getintvar(csi,*(long *)csi->ip);
  701.                 csi->ip+=4;
  702.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  703.                 csi->ip+=4;
  704.                 if(lp) {
  705.                     if(pp && *pp)
  706.                         *lp=**pp;
  707.                     else
  708.                         *lp=0; }
  709.                 return(0);
  710.             case GETSTR_VAR:
  711.             case GETLINE_VAR:
  712.             case GETNAME_VAR:
  713.             case GETSTRUPR_VAR:
  714.             case GETSTR_MODE:
  715.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  716.                 csi->ip+=4;
  717.                 i=*(csi->ip++);
  718.                 csi->logic=LOGIC_FALSE;
  719.                 switch(*(csi->ip-6)) {
  720.                     case GETNAME_VAR:
  721.                         getstr(buf,i,K_UPRLWR);
  722.                         break;
  723.                     case GETSTRUPR_VAR:
  724.                         getstr(buf,i,K_UPPER);
  725.                         break;
  726.                     case GETLINE_VAR:
  727.                         getstr(buf,i,K_LINE);
  728.                         break;
  729.                     case GETSTR_MODE:
  730.                         l=*(long *)csi->ip;
  731.                         csi->ip+=4;
  732.                         if(l&K_EDIT) {
  733.                             if(pp && *pp)
  734.                                 strcpy(buf,*pp);
  735.                             else
  736.                                 buf[0]=0; }
  737.                         getstr(buf,i,l);
  738.                         break;
  739.                     default:
  740.                         getstr(buf,i,0); }
  741.                 if(sys_status&SS_ABORT)
  742.                     return(0);
  743.                 if(pp) {
  744.                     *pp=copystrvar(csi,*pp,buf);
  745.                     csi->logic=LOGIC_TRUE; }
  746.                 return(0);
  747.             case GETNUM_VAR:
  748.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  749.                 if(!pp)
  750.                     lp=getintvar(csi,*(long *)csi->ip);
  751.                 csi->ip+=4;
  752.                 i=*(short *)csi->ip;
  753.                 csi->ip+=2;
  754.                 csi->logic=LOGIC_FALSE;
  755.                 l=getnum(i);
  756.                 if(!pp && !lp)
  757.                     return(0);
  758.                 if(pp) {
  759.                     if(l<=0)
  760.                         str[0]=0;
  761.                     else
  762.                         ltoa(l,str,10);
  763.                     *pp=copystrvar(csi,*pp,str);
  764.                     csi->logic=LOGIC_TRUE;
  765.                     return(0); }
  766.                 if(lp) {
  767.                     *lp=l;
  768.                     csi->logic=LOGIC_TRUE; }
  769.                 return(0);
  770.  
  771.             case SHIFT_STR_VAR:
  772.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  773.                 csi->ip+=4;
  774.                 i=*(csi->ip++);
  775.                 if(!pp || !*pp)
  776.                     return(0);
  777.                 if(strlen(*pp)>=i)
  778.                     memmove(*pp,*pp+i,strlen(*pp)+1);
  779.                 return(0);
  780.  
  781.             case CHKFILE_VAR:
  782.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  783.                 csi->ip+=4;
  784.                 if(pp && *pp && fexist(cmdstr(*pp,path,csi->str,buf)))
  785.                     csi->logic=LOGIC_TRUE;
  786.                 else
  787.                     csi->logic=LOGIC_FALSE;
  788.                 return(0);
  789.             case PRINTFILE_VAR_MODE:
  790.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  791.                 csi->ip+=4;
  792.                 i=*(short *)(csi->ip);
  793.                 csi->ip+=2;
  794.                 if(pp && *pp)
  795.                     printfile(*pp,i);
  796.                 return(0);
  797.             case PRINTTAIL_VAR_MODE:
  798.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  799.                 csi->ip+=4;
  800.                 i=*(short *)(csi->ip);
  801.                 csi->ip+=2;
  802.                 j=*csi->ip;
  803.                 csi->ip++;
  804.                 if(pp && *pp)
  805.                     printtail(*pp,j,i);
  806.                 return(0);
  807.             case SEND_FILE_VIA:
  808.             case RECEIVE_FILE_VIA:
  809.                 j=*(csi->ip-1);
  810.                 ch=*(csi->ip++);    /* Protocol */
  811.                 cmdstr(csi->ip,csi->str,csi->str,str);
  812.                 while(*(csi->ip++));    /* Find NULL */
  813.                 for(i=0;i<total_prots;i++)
  814.                     if(prot[i]->mnemonic==ch && chk_ar(prot[i]->ar,useron))
  815.                         break;
  816.                 csi->logic=LOGIC_FALSE;
  817.                 if(i<total_prots)
  818.                     if(external(cmdstr(j==SEND_FILE_VIA
  819.                         ? prot[i]->dlcmd : prot[i]->ulcmd,str,str,buf)
  820.                         ,EX_OUTL)==0)
  821.                         csi->logic=LOGIC_TRUE;
  822.                 return(0);
  823.             case SEND_FILE_VIA_VAR:
  824.             case RECEIVE_FILE_VIA_VAR:
  825.                 j=*(csi->ip-1);
  826.                 ch=*(csi->ip++);    /* Protocol */
  827.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  828.                 csi->ip+=4;
  829.                 for(i=0;i<total_prots;i++)
  830.                     if(prot[i]->mnemonic==ch && chk_ar(prot[i]->ar,useron))
  831.                         break;
  832.                 csi->logic=LOGIC_FALSE;
  833.                 if(!pp || !(*pp))
  834.                     return(0);
  835.                 if(i<total_prots)
  836.                     if(external(cmdstr(j==SEND_FILE_VIA_VAR
  837.                          ? prot[i]->dlcmd : prot[i]->ulcmd,*pp,*pp,buf)
  838.                         ,EX_OUTL)==0)
  839.                         csi->logic=LOGIC_TRUE;
  840.                 return(0);
  841.  
  842.             default:
  843.                 errormsg(WHERE,ERR_CHK,"var sub-instruction",*(csi->ip-1));
  844.                 return(0); }
  845.  
  846.     case CS_FIO_FUNCTION:
  847.         switch(*(csi->ip++)) {    /* sub-op-code stored as next byte */
  848.             case FIO_OPEN:
  849.             case FIO_OPEN_VAR:
  850.                 lp=getintvar(csi,*(long *)csi->ip);
  851.                 csi->ip+=4;
  852.                 w=*(ushort *)csi->ip;
  853.                 csi->ip+=2;
  854.                 csi->logic=LOGIC_FALSE;
  855.                 if(*(csi->ip-7)==FIO_OPEN) {
  856.                     cmdstr(csi->ip,path,csi->str,str);
  857.                     while(*(csi->ip++)); }     /* skip filename */
  858.                 else {
  859.                     (char **)pp=getstrvar(csi,*(long *)csi->ip);
  860.                     csi->ip+=4;
  861.                     if(!pp || !*pp)
  862.                         return(0);
  863.                     strcpy(str,*pp); }
  864.                 if(csi->files>=MAX_FOPENS)
  865.                     return(0);
  866.                 if(lp) {
  867.                     /* Access flags are not cross-platform, so convert */
  868.                     i=0;
  869.                     if(w&1)     i|=O_RDONLY;
  870.                     if(w&2)     i|=O_WRONLY;
  871.                     if(w&4)     i|=O_RDWR;
  872.                     if(w&0x040) i|=O_DENYNONE;
  873.                     if(w&0x100) i|=O_CREAT;
  874.                     if(w&0x200) i|=O_TRUNC;
  875.                     if(w&0x400) i|=O_EXCL;
  876.                     if(w&0x800) i|=O_APPEND;
  877.                     *lp=(long)fnopen(&j,str,i);
  878.                     if(*lp) {
  879.                         for(i=0;i<csi->files;i++)
  880.                             if(!csi->file[i])
  881.                                 break;
  882.                         csi->file[i]=(FILE *)*lp;
  883.                         if(i==csi->files)
  884.                             csi->files++;
  885.                         csi->logic=LOGIC_TRUE; } }
  886.                 return(0);
  887.             case FIO_CLOSE:
  888.                 lp=getintvar(csi,*(long *)csi->ip);
  889.                 csi->ip+=4;
  890.                 if(lp && *lp) {
  891.                     csi->logic=fclose((FILE *)*lp);
  892.                     for(i=0;i<csi->files;i++)
  893.                         if(csi->file[i]==(FILE *)*lp)
  894.                             csi->file[i]=0; }
  895.                 else
  896.                     csi->logic=LOGIC_FALSE;
  897.                 return(0);
  898.             case FIO_FLUSH:
  899.                 lp=getintvar(csi,*(long *)csi->ip);
  900.                 csi->ip+=4;
  901.                 if(lp && *lp)
  902.                     csi->logic=fflush((FILE *)*lp);
  903.                 else
  904.                     csi->logic=LOGIC_FALSE;
  905.                 return(0);
  906.             case FIO_READ:
  907.             case FIO_READ_VAR:
  908.                 lp1=getintvar(csi,*(long *)csi->ip);        /* Handle */
  909.                 csi->ip+=4;
  910.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  911.                 if(!pp)
  912.                     lp2=getintvar(csi,*(long *)csi->ip);
  913.                 csi->ip+=4;
  914.                 csi->logic=LOGIC_FALSE;
  915.                 if(*(csi->ip-9)==FIO_READ) {
  916.                     i=*(short *)csi->ip;
  917.                     csi->ip+=2; /* Length */ }
  918.                 else {            /* FIO_READ_VAR */
  919.                     vp=getintvar(csi,*(long *)csi->ip);
  920.                     csi->ip+=4;
  921.                     if(!vp)
  922.                         return(0);
  923.                     i=*(short *)vp; }
  924.                 if(i>1024)
  925.                     i=1024;
  926.                 if(!lp1 || !(*lp1) || (!pp && !lp2))
  927.                     return(0);
  928.                 if(pp) {
  929.                     if(i<1) {
  930.                         if(*pp && **pp)
  931.                             i=strlen(*pp);
  932.                         else
  933.                             i=128; }
  934.                     if((j=fread(buf,1,i,(FILE *)*lp1))==i)
  935.                         csi->logic=LOGIC_TRUE;
  936.                     buf[j]=0;
  937.                     if(csi->etx) {
  938.                         p=strchr(buf,csi->etx);
  939.                         if(p) *p=0; }
  940.                     *pp=copystrvar(csi,*pp,buf); }
  941.                 else {
  942.                     *lp2=0;
  943.                     if(i>4 || i<1) i=4;
  944.                     if(fread(lp2,1,i,(FILE *)*lp1)==i)
  945.                         csi->logic=LOGIC_TRUE; }
  946.                 return(0);
  947.             case FIO_READ_LINE:
  948.                 lp1=getintvar(csi,*(long *)csi->ip);        /* Handle */
  949.                 csi->ip+=4;
  950.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  951.                 if(!pp)
  952.                     lp2=getintvar(csi,*(long *)csi->ip);
  953.                 csi->ip+=4;
  954.                 csi->logic=LOGIC_FALSE;
  955.                 if(!lp1 || !(*lp1) || feof((FILE *)*lp1) || (!pp && !lp2))
  956.                     return(0);
  957.                 csi->logic=LOGIC_TRUE;
  958.                 for(i=0;i<1024 /* && !eof(*lp1) removed 1/23/96 */;i++) {
  959.                     if(!fread(buf+i,1,1,(FILE *)*lp1))
  960.                         break;
  961.                     if(*(buf+i)==LF) {
  962.                         i++;
  963.                         break; } }
  964.                 buf[i]=0;
  965.                 if(csi->etx) {
  966.                     p=strchr(buf,csi->etx);
  967.                     if(p) *p=0; }
  968.                 if(pp)
  969.                     *pp=copystrvar(csi,*pp,buf);
  970.                 else
  971.                     *lp2=strtol(buf,0,0);
  972.                 return(0);
  973.             case FIO_WRITE:
  974.             case FIO_WRITE_VAR:
  975.                 lp1=getintvar(csi,*(long *)csi->ip);
  976.                 csi->ip+=4;
  977.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  978.                 if(!pp)
  979.                     lp2=getintvar(csi,*(long *)csi->ip);
  980.                 csi->ip+=4;
  981.                 csi->logic=LOGIC_FALSE;
  982.                 if(*(csi->ip-9)==FIO_WRITE) {
  983.                     i=*(short *)csi->ip;
  984.                     csi->ip+=2; /* Length */ }
  985.                 else {            /* FIO_WRITE_VAR */
  986.                     vp=getintvar(csi,*(long *)csi->ip);
  987.                     csi->ip+=4;
  988.                     if(!vp)
  989.                         return(0);
  990.                     i=*(short *)vp; }
  991.                 if(i>1024)
  992.                     i=1024;
  993.                 if(!lp1 || !(*lp1) || (!pp && !lp2) || (pp && !*pp))
  994.                     return(0);
  995.                 if(pp) {
  996.                     j=strlen(*pp);
  997.                     if(i<1) i=j;
  998.                     if(j>i) j=i;
  999.                     j=fwrite(*pp,1,j,(FILE *)*lp1);
  1000.                     if(j<i) {
  1001.                         memset(buf,csi->etx,i-j);
  1002.                         fwrite(buf,1,i-j,(FILE *)*lp1); }
  1003.                     csi->logic=LOGIC_TRUE; }
  1004.                 else {
  1005.                     if(i<1 || i>4) i=4;
  1006.                     if(fwrite(lp2,1,i,(FILE *)*lp1)==i)
  1007.                         csi->logic=LOGIC_TRUE; }
  1008.                 return(0);
  1009.             case FIO_GET_LENGTH:
  1010.                 lp1=getintvar(csi,*(long *)csi->ip);
  1011.                 csi->ip+=4;
  1012.                 lp2=getintvar(csi,*(long *)csi->ip);
  1013.                 csi->ip+=4;
  1014.                 if(lp1 && *lp1 && lp2)
  1015.                     *lp2=filelength(fileno((FILE *)*lp1));
  1016.                 return(0);
  1017.             case FIO_GET_TIME:
  1018.                 lp1=getintvar(csi,*(long *)csi->ip);
  1019.                 csi->ip+=4;
  1020.                 lp2=getintvar(csi,*(long *)csi->ip);
  1021.                 csi->ip+=4;
  1022.                 if(lp1 && *lp1 && lp2) {
  1023.                     getftime(fileno((FILE *)*lp1),&ft);
  1024.                     *lp2=ftimetounix(ft); }
  1025.                 return(0);
  1026.             case FIO_SET_TIME:
  1027.                 lp1=getintvar(csi,*(long *)csi->ip);
  1028.                 csi->ip+=4;
  1029.                 lp2=getintvar(csi,*(long *)csi->ip);
  1030.                 csi->ip+=4;
  1031.                 if(lp1 && *lp1 && lp2) {
  1032.                     ft=unixtoftime(*lp2);
  1033.                     setftime(fileno((FILE *)*lp1),&ft); }
  1034.                 return(0);
  1035.             case FIO_EOF:
  1036.                 lp=getintvar(csi,*(long *)csi->ip);
  1037.                 csi->ip+=4;
  1038.                 csi->logic=LOGIC_FALSE;
  1039.                 if(lp && *lp)
  1040.                     if(ftell((FILE *)*lp)>=filelength(fileno((FILE *)*lp)))
  1041.                         csi->logic=LOGIC_TRUE;
  1042.                 return(0);
  1043.             case FIO_GET_POS:
  1044.                 lp1=getintvar(csi,*(long *)csi->ip);
  1045.                 csi->ip+=4;
  1046.                 lp2=getintvar(csi,*(long *)csi->ip);
  1047.                 csi->ip+=4;
  1048.                 if(lp1 && *lp1 && lp2)
  1049.                     *lp2=ftell((FILE *)*lp1);
  1050.                 return(0);
  1051.             case FIO_SEEK:
  1052.             case FIO_SEEK_VAR:
  1053.                 lp1=getintvar(csi,*(long *)csi->ip);
  1054.                 csi->ip+=4;
  1055.                 csi->logic=LOGIC_FALSE;
  1056.                 if(*(csi->ip-5)==FIO_SEEK) {
  1057.                     l=*(long *)csi->ip;
  1058.                     csi->ip+=4; }
  1059.                 else {
  1060.                     lp2=getintvar(csi,*(long *)csi->ip);
  1061.                     csi->ip+=4;
  1062.                     if(!lp2) {
  1063.                         csi->ip+=2;
  1064.                         return(0); }
  1065.                     l=*lp2; }
  1066.                 i=*(short *)csi->ip;
  1067.                 csi->ip+=2;
  1068.                 if(lp1 && *lp1)
  1069.                     if(fseek((FILE *)*lp1,l,i)!=-1)
  1070.                         csi->logic=LOGIC_TRUE;
  1071.                 return(0);
  1072.             case FIO_LOCK:
  1073.             case FIO_LOCK_VAR:
  1074.                 lp1=getintvar(csi,*(long *)csi->ip);
  1075.                 csi->ip+=4;
  1076.                 csi->logic=LOGIC_FALSE;
  1077.                 if(*(csi->ip-5)==FIO_LOCK) {
  1078.                     l=*(long *)csi->ip;
  1079.                     csi->ip+=4; }
  1080.                 else {
  1081.                     lp2=getintvar(csi,*(long *)csi->ip);
  1082.                     csi->ip+=4;
  1083.                     if(!lp2)
  1084.                         return(0);
  1085.                     l=*lp2; }
  1086.                 if(lp1 && *lp1) {
  1087.                     fflush((FILE *)*lp1);
  1088.                     lseek(fileno((FILE *)*lp1),ftell((FILE *)*lp1),SEEK_SET);
  1089.                     csi->logic=locking(fileno((FILE *)*lp1),LK_LOCK,l); }
  1090.                 return(0);
  1091.             case FIO_UNLOCK:
  1092.             case FIO_UNLOCK_VAR:
  1093.                 lp1=getintvar(csi,*(long *)csi->ip);
  1094.                 csi->ip+=4;
  1095.                 csi->logic=LOGIC_FALSE;
  1096.                 if(*(csi->ip-5)==FIO_UNLOCK) {
  1097.                     l=*(long *)csi->ip;
  1098.                     csi->ip+=4; }
  1099.                 else {
  1100.                     lp2=getintvar(csi,*(long *)csi->ip);
  1101.                     csi->ip+=4;
  1102.                     if(!lp2)
  1103.                         return(0);
  1104.                     l=*lp2; }
  1105.                 if(lp1 && *lp1) {
  1106.                     fflush((FILE *)*lp1);
  1107.                     lseek(fileno((FILE *)*lp1),ftell((FILE *)*lp1),SEEK_SET);
  1108.                     csi->logic=locking(fileno((FILE *)*lp1),LK_UNLCK,l); }
  1109.                 return(0);
  1110.             case FIO_SET_LENGTH:
  1111.             case FIO_SET_LENGTH_VAR:
  1112.                 lp1=getintvar(csi,*(long *)csi->ip);
  1113.                 csi->ip+=4;
  1114.                 csi->logic=LOGIC_FALSE;
  1115.                 if(*(csi->ip-5)==FIO_SET_LENGTH) {
  1116.                     l=*(long *)csi->ip;
  1117.                     csi->ip+=4; }
  1118.                 else {
  1119.                     lp2=getintvar(csi,*(long *)csi->ip);
  1120.                     csi->ip+=4;
  1121.                     if(!lp2)
  1122.                         return(0);
  1123.                     l=*lp2; }
  1124.                 if(lp1 && *lp1)
  1125.                     csi->logic=chsize(fileno((FILE *)*lp1),l);
  1126.                 return(0);
  1127.             case FIO_PRINTF:
  1128.                 lp1=getintvar(csi,*(long *)csi->ip);
  1129.                 csi->ip+=4;
  1130.                 strcpy(str,csi->ip);
  1131.                 while(*(csi->ip++));    /* Find NULL */
  1132.                 j=*(csi->ip++);         /* total args */
  1133.                 for(i=0;i<j;i++) {
  1134.                     vp=getstrvar(csi,*(long *)csi->ip);
  1135.                     if(!vp) {
  1136.                         lp2=getintvar(csi,*(long *)csi->ip);
  1137.                         if(!lp2)
  1138.                             arglist[i]=0;
  1139.                         else
  1140.                             arglist[i]=(void *)*lp2; }
  1141.                     else
  1142.                         arglist[i]=*(char **)vp;
  1143.                     csi->ip+=4; }
  1144.                 vsprintf(tmp,str,arglist);
  1145.                 if(lp1 && *lp1) {
  1146.                     cmdstr(tmp,path,csi->str,str);
  1147.                     fwrite(str,1,strlen(str),(FILE *)*lp1); }
  1148.                 return(0);
  1149.             case FIO_SET_ETX:
  1150.                 csi->etx=*(csi->ip++);
  1151.                 return(0);
  1152.             case REMOVE_FILE:
  1153.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  1154.                 csi->ip+=4;
  1155.                 if(pp && *pp && remove(*pp)==0)
  1156.                     csi->logic=LOGIC_TRUE;
  1157.                 else
  1158.                     csi->logic=LOGIC_FALSE;
  1159.                 return(0);
  1160.             case RENAME_FILE:
  1161.             case COPY_FILE:
  1162.             case MOVE_FILE:
  1163.                 (char **)pp1=getstrvar(csi,*(long *)csi->ip);
  1164.                 csi->ip+=4; /* Skip variable name */
  1165.                 (char **)pp2=getstrvar(csi,*(long *)csi->ip);
  1166.                 csi->ip+=4;
  1167.                 if(pp1 && *pp1 && pp2 && *pp2)
  1168.                     switch(*(csi->ip-9)) {
  1169.                         case RENAME_FILE:
  1170.                             csi->logic=rename(*pp1,*pp2);
  1171.                             break;
  1172.                         case COPY_FILE:
  1173.                             csi->logic=mv(*pp1,*pp2,1);
  1174.                             break;
  1175.                         case MOVE_FILE:
  1176.                             csi->logic=mv(*pp1,*pp2,0);
  1177.                             break; }
  1178.                 else
  1179.                     csi->logic=LOGIC_FALSE;
  1180.                 return(0);
  1181.             case GET_FILE_ATTRIB:
  1182.             case SET_FILE_ATTRIB:
  1183.                 lp=getintvar(csi,*(long *)csi->ip);
  1184.                 csi->ip+=4;
  1185.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  1186.                 csi->ip+=4;
  1187.                 if(pp && *pp && lp) {
  1188.                     if(*(csi->ip-9)==GET_FILE_ATTRIB)
  1189.                         *lp=_chmod(*pp,0,0);
  1190.                     else
  1191.                         *lp=_chmod(*pp,1,(int)*lp); }
  1192.                 return(0);
  1193.             case MAKE_DIR:
  1194.             case REMOVE_DIR:
  1195.             case CHANGE_DIR:
  1196.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  1197.                 csi->ip+=4;
  1198.                 if(pp && *pp)
  1199.                     switch(*(csi->ip-5)) {
  1200.                         case MAKE_DIR:
  1201.                             csi->logic=mkdir(*pp);
  1202.                             break;
  1203.                         case REMOVE_DIR:
  1204.                             csi->logic=rmdir(*pp);
  1205.                             break;
  1206.                         case CHANGE_DIR:
  1207.                             csi->logic=chdir(*pp);
  1208.                             break; }
  1209.                 else
  1210.                     csi->logic=LOGIC_FALSE;
  1211.                 return(0);
  1212.             case OPEN_DIR:
  1213.                 lp=getintvar(csi,*(long *)csi->ip);
  1214.                 csi->ip+=4;
  1215.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  1216.                 csi->ip+=4;
  1217.                 csi->logic=LOGIC_FALSE;
  1218.                 if(pp && *pp && lp) {
  1219.                     *lp=(long)opendir((char *)*pp);
  1220.                     if(*lp)
  1221.                         csi->logic=LOGIC_TRUE; }
  1222.                 return(0);
  1223.             case READ_DIR:
  1224.                 lp=getintvar(csi,*(long *)csi->ip);
  1225.                 csi->ip+=4;
  1226.                 (char **)pp=getstrvar(csi,*(long *)csi->ip);
  1227.                 csi->ip+=4;
  1228.                 csi->logic=LOGIC_FALSE;
  1229.                 if(pp && lp) {
  1230.                     de=readdir((DIR *)(*lp));
  1231.                     if(de!=NULL) {
  1232.                         csi->logic=LOGIC_TRUE;
  1233.                         *pp=copystrvar(csi,*pp,de->d_name); } }
  1234.                 return(0);
  1235.             case REWIND_DIR:
  1236.                 lp=getintvar(csi,*(long *)csi->ip);
  1237.                 csi->ip+=4;
  1238.                 if(lp) {
  1239.                     rewinddir((DIR *)(*lp));
  1240.                     csi->logic=LOGIC_TRUE; }
  1241.                 else
  1242.                     csi->logic=LOGIC_FALSE;
  1243.                 return(0);
  1244.             case CLOSE_DIR:
  1245.                 lp=getintvar(csi,*(long *)csi->ip);
  1246.                 csi->ip+=4;
  1247.                 if(lp && closedir((DIR *)(*lp))==0)
  1248.                     csi->logic=LOGIC_TRUE;
  1249.                 else
  1250.                     csi->logic=LOGIC_FALSE;
  1251.                 return(0);
  1252.             default:
  1253.                 errormsg(WHERE,ERR_CHK,"fio sub-instruction",*(csi->ip-1));
  1254.                 return(0); }
  1255.  
  1256.  
  1257.     case CS_SWITCH:
  1258.         lp=getintvar(csi,*(long *)csi->ip);
  1259.         csi->ip+=4;
  1260.         if(!lp) {
  1261.             skipto(csi,CS_END_SWITCH);
  1262.             csi->ip++; }
  1263.         else {
  1264.             csi->misc|=CS_IN_SWITCH;
  1265.             csi->switch_val=*lp; }
  1266.         return(0);
  1267.     case CS_CASE:
  1268.         l=*(long *)csi->ip;
  1269.         csi->ip+=4;
  1270.         if(csi->misc&CS_IN_SWITCH && csi->switch_val!=l)
  1271.             skipto(csi,CS_NEXTCASE);
  1272.         else
  1273.             csi->misc&=~CS_IN_SWITCH;
  1274.         return(0);
  1275.     case CS_COMPARE_ARS:
  1276.         i=*(csi->ip++);  /* Length of ARS stored as byte before ARS */
  1277.         csi->logic=!chk_ar(csi->ip,useron);
  1278.         csi->ip+=i;
  1279.         return(0);
  1280.     case CS_TOGGLE_USER_MISC:
  1281.         useron.misc^=*(long *)csi->ip;
  1282.         putuserrec(useron.number,U_MISC,8,ultoa(useron.misc,tmp,16));
  1283.         csi->ip+=4;
  1284.         return(0);
  1285.     case CS_COMPARE_USER_MISC:
  1286.         if((useron.misc&*(long *)csi->ip)==*(long *)csi->ip)
  1287.             csi->logic=LOGIC_TRUE;
  1288.         else
  1289.             csi->logic=LOGIC_FALSE;
  1290.         csi->ip+=4;
  1291.         return(0);
  1292.     case CS_TOGGLE_USER_CHAT:
  1293.         useron.chat^=*(long *)csi->ip;
  1294.         putuserrec(useron.number,U_CHAT,8,ultoa(useron.chat,tmp,16));
  1295.         csi->ip+=4;
  1296.         return(0);
  1297.     case CS_COMPARE_USER_CHAT:
  1298.         if((useron.chat&*(long *)csi->ip)==*(long *)csi->ip)
  1299.             csi->logic=LOGIC_TRUE;
  1300.         else
  1301.             csi->logic=LOGIC_FALSE;
  1302.         csi->ip+=4;
  1303.         return(0);
  1304.     case CS_TOGGLE_USER_QWK:
  1305.         useron.qwk^=*(long *)csi->ip;
  1306.         putuserrec(useron.number,U_QWK,8,ultoa(useron.qwk,tmp,16));
  1307.         csi->ip+=4;
  1308.         return(0);
  1309.     case CS_COMPARE_USER_QWK:
  1310.         if((useron.qwk&*(long *)csi->ip)==*(long *)csi->ip)
  1311.             csi->logic=LOGIC_TRUE;
  1312.         else
  1313.             csi->logic=LOGIC_FALSE;
  1314.         csi->ip+=4;
  1315.         return(0);
  1316.     case CS_REPLACE_TEXT:
  1317.         i=*(ushort *)csi->ip;
  1318.         csi->ip+=2;
  1319.         i--;
  1320.         if(i>=TOTAL_TEXT) {
  1321.             errormsg(WHERE,ERR_CHK,"replace text #",i);
  1322.             while(*(csi->ip++));     /* Find NULL */
  1323.             return(0); }
  1324.         if(text[i]!=text_sav[i] && text[i]!=nulstr)
  1325.             FREE(text[i]);
  1326.         j=strlen(cmdstr(csi->ip,path,csi->str,buf));
  1327.         if(!j)
  1328.             text[i]=nulstr;
  1329.         else
  1330.             text[i]=MALLOC(j+1);
  1331.         if(!text[i]) {
  1332.             errormsg(WHERE,ERR_ALLOC,"replacement text",j);
  1333.             while(*(csi->ip++));     /* Find NULL */
  1334.             text[i]=text_sav[i];
  1335.             return(0); }
  1336.         if(j)
  1337.             strcpy(text[i],buf);
  1338.         while(*(csi->ip++));     /* Find NULL */
  1339.         return(0);
  1340.     case CS_USE_INT_VAR:    // Self-modifying code!
  1341.         (char **)pp=getstrvar(csi,*(long *)csi->ip);
  1342.         if(pp && *pp)
  1343.             l=strtol(*pp,0,0);
  1344.         else {
  1345.             lp=getintvar(csi,*(long *)csi->ip);
  1346.             if(lp)
  1347.                 l=*lp;
  1348.             else
  1349.                 l=0; }
  1350.         csi->ip+=4;             // Variable
  1351.         i=*(csi->ip++);         // Offset
  1352.         if(i<1 || csi->ip+1+i>=csi->cs+csi->length) {
  1353.             errormsg(WHERE,ERR_CHK,"offset",i);
  1354.             csi->ip++;
  1355.             return(0); }
  1356.         switch(*(csi->ip++)) {    // Length
  1357.             case sizeof(char):
  1358.                 *(csi->ip+i)=(char)l;
  1359.                 break;
  1360.             case sizeof(short):
  1361.                 *((short *)(csi->ip+i))=(short)l;
  1362.                 break;
  1363.             case sizeof(long):
  1364.                 *((long *)(csi->ip+i))=l;
  1365.                 break;
  1366.             default:
  1367.                 errormsg(WHERE,ERR_CHK,"length",*(csi->ip-1));
  1368.                 break; }
  1369.         return(0);
  1370.     default:
  1371.         errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  1372.         return(0); }
  1373. }
  1374.