home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 September / PCO_0998.ISO / filesbbs / dos / sbbs_src.exe / SBBS / EXEC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-13  |  38.6 KB  |  1,558 lines
  1. #line 1 "EXEC.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.  
  8. char *readtext(long *line, FILE *stream);
  9.  
  10. extern csi_t main_csi;
  11. extern FILE *nodefile_fp,*node_ext_fp,*logfile_fp;
  12.  
  13. uint global_str_vars=0;
  14. char **global_str_var=0;
  15. long *global_str_var_name=0;
  16. uint global_int_vars=0;
  17. long *global_int_var=0;
  18. long *global_int_var_name=0;
  19.  
  20. char *sysvar_p[MAX_SYSVARS]={NULL};
  21. int sysvar_pi=0;
  22. long sysvar_l[MAX_SYSVARS]={0L};
  23. int sysvar_li=0;
  24.  
  25. char **getstrvar(csi_t *bin, long name)
  26. {
  27.     int i;
  28.  
  29. if(sysvar_pi==MAX_SYSVARS) sysvar_pi=0;
  30. switch(name) {
  31.     case 0:
  32.         return((char **)&(bin->str));
  33.     case 0x490873f1:
  34.         sysvar_p[sysvar_pi]=useron.alias;
  35.         break;
  36.     case 0x5de44e8b:
  37.         sysvar_p[sysvar_pi]=useron.name;
  38.         break;
  39.     case 0x979ef1de:
  40.         sysvar_p[sysvar_pi]=useron.handle;
  41.         break;
  42.     case 0xc8cd5fb7:
  43.         sysvar_p[sysvar_pi]=useron.comp;
  44.         break;
  45.     case 0xcc7aca99:
  46.         sysvar_p[sysvar_pi]=useron.note;
  47.         break;
  48.     case 0xa842c43b:
  49.         sysvar_p[sysvar_pi]=useron.address;
  50.         break;
  51.     case 0x4ee1ff3a:
  52.         sysvar_p[sysvar_pi]=useron.location;
  53.         break;
  54.     case 0xf000aa78:
  55.         sysvar_p[sysvar_pi]=useron.zipcode;
  56.         break;
  57.     case 0xcdb7e4a9:
  58.         sysvar_p[sysvar_pi]=useron.pass;
  59.         break;
  60.     case 0x94d59a7a:
  61.         sysvar_p[sysvar_pi]=useron.birth;
  62.         break;
  63.     case 0xec2b8fb8:
  64.         sysvar_p[sysvar_pi]=useron.phone;
  65.         break;
  66.     case 0x08f65a2a:
  67.         sysvar_p[sysvar_pi]=useron.modem;
  68.         break;
  69.     case 0xc7e0e8ce:
  70.         sysvar_p[sysvar_pi]=useron.netmail;
  71.         break;
  72.     case 0xd3606303:
  73.         sysvar_p[sysvar_pi]=useron.tmpext;
  74.         break;
  75.     case 0x3178f9d6:
  76.         sysvar_p[sysvar_pi]=useron.comment;
  77.         break;
  78.  
  79.     case 0x41239e21:
  80.         sysvar_p[sysvar_pi]=connection;
  81.         break;
  82.     case 0xe9f1fad0:
  83.         sysvar_p[sysvar_pi]=cap_fname;
  84.         break;
  85.     case 0x90fc82b4:
  86.         sysvar_p[sysvar_pi]=cid;
  87.         break;
  88.     case 0x15755030:
  89.         return((char **)&comspec);
  90.  
  91.     case 0xf19cd046:
  92.         sysvar_p[sysvar_pi]=wordwrap;
  93.         break;
  94.  
  95.     default:
  96.         if(bin->str_var && bin->str_var_name)
  97.             for(i=0;i<bin->str_vars;i++)
  98.                 if(bin->str_var_name[i]==name)
  99.                     return((char **)&(bin->str_var[i]));
  100.         if(global_str_var && global_str_var_name)
  101.             for(i=0;i<global_str_vars;i++)
  102.                 if(global_str_var_name[i]==name)
  103.                     return(&(global_str_var[i]));
  104.         return(NULL); }
  105.  
  106. return((char **)&sysvar_p[sysvar_pi++]);
  107. }
  108.  
  109. long *getintvar(csi_t *bin, long name)
  110. {
  111.     int i;
  112.  
  113. if(sysvar_li==MAX_SYSVARS) sysvar_li=0;
  114. switch(name) {
  115.     case 0:
  116.         sysvar_l[sysvar_li]=strtol(bin->str,0,0);
  117.         break;
  118.     case 0x908ece53:
  119.         sysvar_l[sysvar_li]=useron.number;
  120.         break;
  121.     case 0xdcedf626:
  122.         sysvar_l[sysvar_li]=useron.uls;
  123.         break;
  124.     case 0xc1093f61:
  125.         sysvar_l[sysvar_li]=useron.dls;
  126.         break;
  127.     case 0x2039a29f:
  128.         sysvar_l[sysvar_li]=useron.posts;
  129.         break;
  130.     case 0x4a9f3955:
  131.         sysvar_l[sysvar_li]=useron.emails;
  132.         break;
  133.     case 0x0c8dcf3b:
  134.         sysvar_l[sysvar_li]=useron.fbacks;
  135.         break;
  136.     case 0x9a13bf95:
  137.         sysvar_l[sysvar_li]=useron.etoday;
  138.         break;
  139.     case 0xc9082cbd:
  140.         sysvar_l[sysvar_li]=useron.ptoday;
  141.         break;
  142.     case 0x7c72376d:
  143.         sysvar_l[sysvar_li]=useron.timeon;
  144.         break;
  145.     case 0xac72c50b:
  146.         sysvar_l[sysvar_li]=useron.textra;
  147.         break;
  148.     case 0x04807a11:
  149.         sysvar_l[sysvar_li]=useron.logons;
  150.         break;
  151.     case 0x52996eab:
  152.         sysvar_l[sysvar_li]=useron.ttoday;
  153.         break;
  154.     case 0x098bdfcb:
  155.         sysvar_l[sysvar_li]=useron.tlast;
  156.         break;
  157.     case 0xbd1cee5d:
  158.         sysvar_l[sysvar_li]=useron.ltoday;
  159.         break;
  160.     case 0x07954570:
  161.         sysvar_l[sysvar_li]=useron.xedit;
  162.         break;
  163.     case 0xedf6aa98:
  164.         sysvar_l[sysvar_li]=useron.shell;
  165.         break;
  166.     case 0x328ed476:
  167.         sysvar_l[sysvar_li]=useron.level;
  168.         break;
  169.     case 0x9e70e855:
  170.         sysvar_l[sysvar_li]=useron.sex;
  171.         break;
  172.     case 0x094cc42c:
  173.         sysvar_l[sysvar_li]=useron.rows;
  174.         break;
  175.     case 0xabc4317e:
  176.         sysvar_l[sysvar_li]=useron.prot;
  177.         break;
  178.     case 0x7dd9aac0:
  179.         sysvar_l[sysvar_li]=useron.leech;
  180.         break;
  181.     case 0x7c602a37:
  182.         return((long *)&useron.misc);
  183.     case 0x61be0d36:
  184.         return((long *)&useron.qwk);
  185.     case 0x665ac227:
  186.         return((long *)&useron.chat);
  187.     case 0x951341ab:
  188.         return((long *)&useron.flags1);
  189.     case 0x0c1a1011:
  190.         return((long *)&useron.flags2);
  191.     case 0x7b1d2087:
  192.         return((long *)&useron.flags3);
  193.     case 0xe579b524:
  194.         return((long *)&useron.flags4);
  195.     case 0x12e7d6d2:
  196.         return((long *)&useron.exempt);
  197.     case 0xfed3115d:
  198.         return((long *)&useron.rest);
  199.     case 0xb65dd6d4:
  200.         return((long *)&useron.ulb);
  201.     case 0xabb91f93:
  202.         return((long *)&useron.dlb);
  203.     case 0x92fb364f:
  204.         return((long *)&useron.cdt);
  205.     case 0xd0a99c72:
  206.         return((long *)&useron.min);
  207.     case 0xd7ae3022:
  208.         return((long *)&useron.freecdt);
  209.     case 0x1ef214ef:
  210.         return((long *)&useron.firston);
  211.     case 0x0ea515b1:
  212.         return((long *)&useron.laston);
  213.     case 0x2aaf9bd3:
  214.         return((long *)&useron.expire);
  215.     case 0x89c91dc8:
  216.         return((long *)&useron.pwmod);
  217.     case 0x5b0d0c54:
  218.         return((long *)&useron.ns_time);
  219.  
  220.     case 0xae256560:
  221.         return((long *)&cur_rate);
  222.     case 0x2b3c257f:
  223.         return((long *)&cur_cps);
  224.     case 0x1c4455ee:
  225.         return((long *)&dte_rate);
  226.     case 0x7fbf958e:
  227.         return((long *)&lncntr);
  228.     case 0x5c1c1500:
  229.         return((long *)&tos);
  230.     case 0x613b690e:
  231.         return((long *)&rows);
  232.     case 0x205ace36:
  233.         return((long *)&autoterm);
  234.     case 0x7d0ed0d1:
  235.         return((long *)&console);
  236.     case 0xbf31a280:
  237.         return((long *)&answertime);
  238.     case 0x83aa2a6a:
  239.         return((long *)&logontime);
  240.     case 0xb50cb889:
  241.         return((long *)&ns_time);
  242.     case 0xae92d249:
  243.         return((long *)&last_ns_time);
  244.     case 0x97f99eef:
  245.         return((long *)&online);
  246.     case 0x381d3c2a:
  247.         return((long *)&sys_status);
  248.     case 0x7e29c819:
  249.         return((long *)&sys_misc);
  250.     case 0x11c83294:
  251.         return((long *)&sys_psnum);
  252.     case 0x02408dc5:
  253.         sysvar_l[sysvar_li]=sys_timezone;
  254.         break;
  255.     case 0x78afeaf1:
  256.         sysvar_l[sysvar_li]=sys_pwdays;
  257.         break;
  258.     case 0xd859385f:
  259.         sysvar_l[sysvar_li]=sys_deldays;
  260.         break;
  261.     case 0x6392dc62:
  262.         sysvar_l[sysvar_li]=sys_autodel;
  263.         break;
  264.     case 0x698d59b4:
  265.         sysvar_l[sysvar_li]=sys_nodes;
  266.         break;
  267.     case 0x6fb1c46e:
  268.         sysvar_l[sysvar_li]=sys_exp_warn;
  269.         break;
  270.     case 0xdf391ca7:
  271.         sysvar_l[sysvar_li]=sys_lastnode;
  272.         break;
  273.     case 0xdd982780:
  274.         sysvar_l[sysvar_li]=sys_autonode;
  275.         break;
  276.     case 0xf53db6c7:
  277.         sysvar_l[sysvar_li]=node_scrnlen;
  278.         break;
  279.     case 0xa1f0fcb7:
  280.         sysvar_l[sysvar_li]=node_scrnblank;
  281.         break;
  282.     case 0x709c07da:
  283.         return((long *)&node_misc);
  284.     case 0xb17e7914:
  285.         sysvar_l[sysvar_li]=node_valuser;
  286.         break;
  287.     case 0xadae168a:
  288.         sysvar_l[sysvar_li]=node_ivt;
  289.         break;
  290.     case 0x2aa89801:
  291.         sysvar_l[sysvar_li]=node_swap;
  292.         break;
  293.     case 0x4f02623a:
  294.         sysvar_l[sysvar_li]=node_minbps;
  295.         break;
  296.     case 0xe7a7fb07:
  297.         sysvar_l[sysvar_li]=node_num;
  298.         break;
  299.     case 0x6c8e350a:
  300.         sysvar_l[sysvar_li]=new_level;
  301.         break;
  302.     case 0xccfe7c5d:
  303.         return((long *)&new_flags1);
  304.     case 0x55f72de7:
  305.         return((long *)&new_flags2);
  306.     case 0x22f01d71:
  307.         return((long *)&new_flags3);
  308.     case 0xbc9488d2:
  309.         return((long *)&new_flags4);
  310.     case 0x4b0aeb24:
  311.         return((long *)&new_exempt);
  312.     case 0x20cb6325:
  313.         return((long *)&new_rest);
  314.     case 0x31178ba2:
  315.         return((long *)&new_cdt);
  316.     case 0x7345219f:
  317.         return((long *)&new_min);
  318.     case 0xb3f64be4:
  319.         sysvar_l[sysvar_li]=new_shell;
  320.         break;
  321.     case 0xa278584f:
  322.         return((long *)&new_misc);
  323.     case 0x7342a625:
  324.         sysvar_l[sysvar_li]=new_expire;
  325.         break;
  326.     case 0x75dc4306:
  327.         sysvar_l[sysvar_li]=new_prot;
  328.         break;
  329.     case 0xfb394e27:
  330.         sysvar_l[sysvar_li]=expired_level;
  331.         break;
  332.     case 0x89b69753:
  333.         return((long *)&expired_flags1);
  334.     case 0x10bfc6e9:
  335.         return((long *)&expired_flags2);
  336.     case 0x67b8f67f:
  337.         return((long *)&expired_flags3);
  338.     case 0xf9dc63dc:
  339.         return((long *)&expired_flags4);
  340.     case 0x0e42002a:
  341.         return((long *)&expired_exempt);
  342.     case 0x4569c62e:
  343.         return((long *)&expired_rest);
  344.     case 0xfcf3542e:
  345.         sysvar_l[sysvar_li]=min_dspace;
  346.         break;
  347.     case 0xcf9ce02c:
  348.         sysvar_l[sysvar_li]=cdt_min_value;
  349.         break;
  350.     case 0xfcb5b274:
  351.         return((long *)&cdt_per_dollar);
  352.     case 0x4db200d2:
  353.         sysvar_l[sysvar_li]=leech_pct;
  354.         break;
  355.     case 0x9a7d9cca:
  356.         sysvar_l[sysvar_li]=leech_sec;
  357.         break;
  358.     case 0x396b7167:
  359.         return((long *)&netmail_cost);
  360.     case 0x5eeaff21:
  361.         sysvar_l[sysvar_li]=netmail_misc;
  362.         break;
  363.     case 0x82d9484e:
  364.         return((long *)&inetmail_cost);
  365.     case 0xe558c608:
  366.         return((long *)&inetmail_misc);
  367.  
  368.     case 0xc6e8539d:
  369.         return((long *)&logon_ulb);
  370.     case 0xdb0c9ada:
  371.         return((long *)&logon_dlb);
  372.     case 0xac58736f:
  373.         return((long *)&logon_uls);
  374.     case 0xb1bcba28:
  375.         return((long *)&logon_dls);
  376.     case 0x9c5051c9:
  377.         return((long *)&logon_posts);
  378.     case 0xc82ba467:
  379.         return((long *)&logon_emails);
  380.     case 0x8e395209:
  381.         return((long *)&logon_fbacks);
  382.     case 0x8b12ba9d:
  383.         return((long *)&posts_read);
  384.     case 0xe51c1956:
  385.         sysvar_l[sysvar_li]=(ulong)logfile_fp;
  386.         break;
  387.     case 0x5a22d4bd:
  388.         sysvar_l[sysvar_li]=(ulong)nodefile_fp;
  389.         break;
  390.     case 0x3a37c26b:
  391.         sysvar_l[sysvar_li]=(ulong)node_ext_fp;
  392.         break;
  393.  
  394.     case 0xeb6c9c73:
  395.         sysvar_l[sysvar_li]=errorlevel;
  396.         break;
  397.  
  398.     case 0x5aaccfc5:
  399.         sysvar_l[sysvar_li]=errno;
  400.         break;
  401.  
  402.     case 0x057e4cd4:
  403.         sysvar_l[sysvar_li]=timeleft;
  404.         break;
  405.  
  406.     case 0x1e5052a7:
  407.         return((long *)&max_minutes);
  408.     case 0xedc643f1:
  409.         return((long *)&max_qwkmsgs);
  410.  
  411.     case 0x430178ec:
  412.         return((long *)&uq);
  413.  
  414.     default:
  415.         if(bin->int_var && bin->int_var_name)
  416.             for(i=0;i<bin->int_vars;i++)
  417.                 if(bin->int_var_name[i]==name)
  418.                     return(&bin->int_var[i]);
  419.         if(global_int_var && global_int_var_name)
  420.             for(i=0;i<global_int_vars;i++)
  421.                 if(global_int_var_name[i]==name)
  422.                     return(&global_int_var[i]);
  423.         return(NULL); }
  424.  
  425. return(&sysvar_l[sysvar_li++]);
  426. }
  427.  
  428. void clearvars(csi_t *bin)
  429. {
  430. bin->str_vars=0;
  431. bin->str_var=NULL;
  432. bin->str_var_name=NULL;
  433. bin->int_vars=0;
  434. bin->int_var=NULL;
  435. bin->int_var_name=NULL;
  436. bin->files=0;
  437. bin->retval=0;
  438. }
  439.  
  440. void freevars(csi_t *bin)
  441. {
  442.     int i;
  443.  
  444. if(bin->str_var) {
  445.     for(i=0;i<bin->str_vars;i++)
  446.         if(bin->str_var[i])
  447.             FREE(bin->str_var[i]);
  448.     FREE(bin->str_var); }
  449. if(bin->int_var)
  450.     FREE(bin->int_var);
  451. if(bin->str_var_name)
  452.     FREE(bin->str_var_name);
  453. if(bin->int_var_name)
  454.     FREE(bin->int_var_name);
  455. for(i=0;i<bin->files;i++)
  456.     if(bin->file[i]) {
  457.         fclose((FILE *)bin->file[i]);
  458.         bin->file[i]=0; }
  459. }
  460.  
  461. /****************************************************************************/
  462. /* Copies a new value (str) into the string variable pointed to by p        */
  463. /* re-allocating if necessary                                                */
  464. /****************************************************************************/
  465. char *copystrvar(csi_t *csi, char *p, char *str)
  466. {
  467.     char *np;    /* New pointer after realloc */
  468.     int i;
  469.  
  470. if(p!=csi->str) {
  471.     if(p)
  472.         for(i=0;i<MAX_SYSVARS;i++)
  473.             if(p==sysvar_p[i])
  474.                 break;
  475.     if(!p || i==MAX_SYSVARS) {        /* Not system variable */
  476.         if((np=REALLOC(p,strlen(str)+1))==NULL)
  477.             errormsg(WHERE,ERR_ALLOC,"variable",strlen(str)+1);
  478.         else
  479.             p=np; } }
  480. if(p)
  481.     strcpy(p,str);
  482. return(p);
  483. }
  484.  
  485.  
  486. long exec_bin(uchar *mod, csi_t *csi)
  487. {
  488.     char    str[128];
  489.     int     i,file;
  490.     csi_t   bin;
  491.  
  492. //lprintf("%s %d\r\n",__FILE__,__LINE__);
  493. memcpy(&bin,csi,sizeof(csi_t));
  494. clearvars(&bin);
  495.  
  496. sprintf(str,"%s%s.BIN",exec_dir,mod);
  497. if((file=nopen(str,O_RDONLY|O_BINARY))==-1) {
  498.     errormsg(WHERE,ERR_OPEN,str,O_RDONLY|O_BINARY);
  499.     return(-1); }
  500.  
  501. //lprintf("%s %d\r\n",__FILE__,__LINE__);
  502. bin.length=filelength(file);
  503. if((bin.cs=(uchar *)MALLOC(bin.length))==NULL) {
  504.     close(file);
  505.     errormsg(WHERE,ERR_ALLOC,str,bin.length);
  506.     return(-1); }
  507. if(lread(file,bin.cs,bin.length)!=bin.length) {
  508.     close(file);
  509.     errormsg(WHERE,ERR_READ,str,bin.length);
  510.     FREE(bin.cs);
  511.     return(-1); }
  512. close(file);
  513.  
  514. bin.ip=bin.cs;
  515. bin.rets=bin.cmdrets=bin.misc=0;
  516. //lprintf("%s %d\r\n",__FILE__,__LINE__);
  517. while(exec(&bin)==0)
  518.     if(!(bin.misc&CS_OFFLINE_EXEC)) {
  519.         checkline();
  520.         if(!online)
  521.             break; }
  522. //lprintf("%s %d logic=%d\r\n",__FILE__,__LINE__,bin.logic);
  523. freevars(&bin);
  524. FREE(bin.cs);
  525. csi->logic=bin.logic;
  526. return(bin.retval);
  527. }
  528.  
  529. /****************************************************************************/
  530. /* Skcsi->ip to a specific instruction                                           */
  531. /****************************************************************************/
  532. void skipto(csi_t *csi, uchar inst)
  533. {
  534.     int i,j;
  535.  
  536. while(csi->ip<csi->cs+csi->length && ((inst&0x80) || *csi->ip!=inst)) {
  537.  
  538.     if(*csi->ip==CS_IF_TRUE || *csi->ip==CS_IF_FALSE
  539.         || (*csi->ip>=CS_IF_GREATER && *csi->ip<=CS_IF_LESS_OR_EQUAL)) {
  540.         csi->ip++;
  541.         skipto(csi,CS_ENDIF);
  542.         csi->ip++;
  543.         continue; }
  544.  
  545.     if(inst==CS_ELSEORENDIF
  546.         && (*csi->ip==CS_ELSE || *csi->ip==CS_ENDIF))
  547.         break;
  548.  
  549.     if(inst==CS_NEXTCASE
  550.         && (*csi->ip==CS_CASE || *csi->ip==CS_DEFAULT
  551.             || *csi->ip==CS_END_SWITCH))
  552.         break;
  553.  
  554.     if(*csi->ip==CS_SWITCH) {
  555.         csi->ip++;
  556.         csi->ip+=4; /* Skip variable name */
  557.         skipto(csi,CS_END_SWITCH);
  558.         csi->ip++;
  559.         continue; }
  560.  
  561.     if(*csi->ip==CS_CASE) {
  562.         csi->ip++;
  563.         csi->ip+=4; /* Skip value */
  564.         skipto(csi,CS_NEXTCASE);
  565.         continue; }
  566.  
  567.     if(*csi->ip==CS_CMDKEY) {
  568.         csi->ip+=2;
  569.         skipto(csi,CS_END_CMD);
  570.         csi->ip++;
  571.         continue; }
  572.     if(*csi->ip==CS_CMDSTR || *csi->ip==CS_CMDKEYS) {
  573.         csi->ip++;              /* skip inst */
  574.         while(*(csi->ip++));    /* skip string */
  575.         skipto(csi,CS_END_CMD);
  576.         csi->ip++;
  577.         continue; }
  578.  
  579.     if(*csi->ip>=CS_FUNCTIONS) {
  580.         csi->ip++;
  581.         continue; }
  582.  
  583.     if(*csi->ip>=CS_MISC) {
  584.         switch(*csi->ip) {
  585.             case CS_VAR_INSTRUCTION:
  586.                 csi->ip++;
  587.                 switch(*(csi->ip++)) {
  588.                     case SHOW_VARS:
  589.                         continue;
  590.                     case PRINT_VAR:
  591.                     case DEFINE_STR_VAR:
  592.                     case DEFINE_INT_VAR:
  593.                     case DEFINE_GLOBAL_STR_VAR:
  594.                     case DEFINE_GLOBAL_INT_VAR:
  595.                     case TIME_INT_VAR:
  596.                     case STRUPR_VAR:
  597.                     case STRLWR_VAR:
  598.                     case TRUNCSP_STR_VAR:
  599.                     case CHKFILE_VAR:
  600.                     case STRIP_CTRL_STR_VAR:
  601.                         csi->ip+=4; /* Skip variable name */
  602.                         continue;
  603.                     case GETSTR_VAR:
  604.                     case GETNAME_VAR:
  605.                     case GETLINE_VAR:
  606.                     case GETSTRUPR_VAR:
  607.                     case SHIFT_STR_VAR:
  608.                     case SEND_FILE_VIA_VAR:
  609.                     case RECEIVE_FILE_VIA_VAR:
  610.                         csi->ip+=4; /* Skip variable name */
  611.                         csi->ip++;    /* Skip char */
  612.                         continue;
  613.                     case PRINTTAIL_VAR_MODE:
  614.                         csi->ip++;    /* Skip length */
  615.                     case PRINTFILE_VAR_MODE:
  616.                     case GETNUM_VAR:
  617.                         csi->ip+=4; /* Skip variable name */
  618.                         csi->ip+=2;  /* Skip max num */
  619.                         continue;
  620.                     case STRNCMP_VAR:
  621.                         csi->ip++;    /* Skip length */
  622.                     case SET_STR_VAR:
  623.                     case COMPARE_STR_VAR:
  624.                     case CAT_STR_VAR:
  625.                     case STRSTR_VAR:
  626.                         csi->ip+=4; /* Skip variable name */
  627.                         while(*(csi->ip++));    /* skip string */
  628.                         continue;
  629.                     case FORMAT_TIME_STR:
  630.                         csi->ip+=4; /* Skip destination variable */
  631.                         while(*(csi->ip++));    /* Skip string */
  632.                         csi->ip+=4; /* Skip int variable */
  633.                         continue;
  634.                     case FORMAT_STR_VAR:    /* SPRINTF */
  635.                         csi->ip+=4; /* Skip destination variable */
  636.                     case VAR_PRINTF:
  637.                         while(*(csi->ip++));    /* Skip string */
  638.                         j=*(csi->ip++); /* Skip number of arguments */
  639.                         for(i=0;i<j;i++)
  640.                             csi->ip+=4; /* Skip arguments */
  641.                         continue;
  642.                     case SEND_FILE_VIA:
  643.                     case RECEIVE_FILE_VIA:
  644.                         csi->ip++;                /* Skip prot */
  645.                         while(*(csi->ip++));    /* Skip filepath */
  646.                         continue;
  647.                     case GETSTR_MODE:
  648.                     case STRNCMP_VARS:
  649.                         csi->ip++;    /* Skip length */
  650.                     default:
  651.                         csi->ip+=8; /* Skip two variable names or var & val */
  652.                         continue; }
  653.  
  654.             case CS_FIO_FUNCTION:
  655.                 csi->ip++;
  656.                 switch(*(csi->ip++)) {
  657.                     case FIO_OPEN:
  658.                         csi->ip+=4;             /* File handle */
  659.                         csi->ip+=2;             /* Access */
  660.                         while(*(csi->ip++));    /* path/filename */
  661.                         continue;
  662.                     case FIO_CLOSE:
  663.                     case FIO_FLUSH:
  664.                     case FIO_EOF:
  665.                     case REMOVE_FILE:
  666.                     case REMOVE_DIR:
  667.                     case CHANGE_DIR:
  668.                     case MAKE_DIR:
  669.                     case REWIND_DIR:
  670.                     case CLOSE_DIR:
  671.                         csi->ip+=4;             /* File handle */
  672.                         continue;
  673.                     case FIO_SET_ETX:
  674.                         csi->ip++;
  675.                         continue;
  676.                     case FIO_PRINTF:
  677.                         csi->ip+=4;             /* File handle */
  678.                         while(*(csi->ip++));    /* String */
  679.                         j=*(csi->ip++);         /* Number of arguments */
  680.                         for(i=0;i<j;i++)
  681.                             csi->ip+=4;         /* Arguments */
  682.                         continue;
  683.                     case FIO_READ:
  684.                     case FIO_WRITE:
  685.                     case FIO_SEEK:
  686.                     case FIO_SEEK_VAR:
  687.                     case FIO_OPEN_VAR:
  688.                         csi->ip+=4;             /* File handle */
  689.                         csi->ip+=4;             /* Variable */
  690.                         csi->ip+=2;             /* Length/access */
  691.                         continue;
  692.                     case FIO_READ_VAR:
  693.                     case FIO_WRITE_VAR:
  694.                         csi->ip+=4;             /* File handle */
  695.                         csi->ip+=4;             /* Buf Variable */
  696.                         csi->ip+=4;             /* Length Variable */
  697.                         continue;
  698.                     default:
  699.                         csi->ip+=4;             /* File handle */
  700.                         csi->ip+=4;             /* Variable */
  701.                         continue; }
  702.  
  703.             case CS_COMPARE_ARS:
  704.                 csi->ip++;
  705.                 csi->ip+=(*csi->ip);
  706.                 csi->ip++;
  707.                 break;
  708.             case CS_TOGGLE_USER_MISC:
  709.             case CS_COMPARE_USER_MISC:
  710.             case CS_TOGGLE_USER_CHAT:
  711.             case CS_COMPARE_USER_CHAT:
  712.             case CS_TOGGLE_USER_QWK:
  713.             case CS_COMPARE_USER_QWK:
  714.                 csi->ip+=5;
  715.                 break;
  716.             case CS_REPLACE_TEXT:
  717.                 csi->ip+=3;     /* skip inst and text # */
  718.                 while(*(csi->ip++));    /* skip string */
  719.                 break;
  720.             case CS_USE_INT_VAR:
  721.                 csi->ip+=7; // inst, var, offset, len
  722.                 break;
  723.             default:
  724.                 csi->ip++; }
  725.         continue; }
  726.  
  727.     if(*csi->ip==CS_ONE_MORE_BYTE) {
  728.         csi->ip++;                /* skip extension */
  729.         csi->ip++;                /* skip instruction */
  730.         continue; }
  731.  
  732.     if(*csi->ip==CS_TWO_MORE_BYTES) {
  733.         csi->ip++;                /* skip extension */
  734.         csi->ip++;                /* skip instruction */
  735.         csi->ip++;                /* skip argument */
  736.         continue; }
  737.  
  738.     if(*csi->ip==CS_THREE_MORE_BYTES) {
  739.         csi->ip++;                /* skip extension */
  740.         csi->ip++;                /* skip instruction */
  741.         csi->ip+=2;             /* skip argument */
  742.         continue; }
  743.  
  744.     if(*csi->ip==CS_STR_FUNCTION) {
  745.         csi->ip++;                /* skip extension */
  746.         csi->ip++;                /* skip instruction */
  747.         while(*(csi->ip++));    /* skip string */
  748.         continue; }
  749.  
  750.     if(*csi->ip>=CS_ASCIIZ) {
  751.         csi->ip++;              /* skip inst */
  752.         while(*(csi->ip++));    /* skip string */
  753.         continue; }
  754.  
  755.     if(*csi->ip>=CS_THREE_BYTE) {
  756.         csi->ip+=3;
  757.         continue; }
  758.  
  759.     if(*csi->ip>=CS_TWO_BYTE) {
  760.         csi->ip+=2;
  761.         continue; }
  762.  
  763.     csi->ip++; }
  764. }
  765.  
  766.  
  767. int exec(csi_t *csi)
  768. {
  769.     uchar    str[256],tmp2[128],buf[1025],*path,ch,*p,**pp,**pp1,**pp2;
  770.     int     i,j,k,s,file,x,y;
  771.     long    l,*lp,*lp1,*lp2;
  772.     stats_t stats;
  773.     time_t    t;
  774.     FILE    *stream;
  775.  
  776. //lprintf("line %d (%d %d %d)\r\n",__LINE__,curgrp,cursub[curgrp],usrsub[curgrp]);
  777. #if 0
  778. if(curgrp>=total_grps)
  779.     curgrp=0;
  780. if(cursub[curgrp]>=total_subs)
  781.     cursub[curgrp]=0;
  782. if(curlib>=total_libs)
  783.     curlib=0;
  784. if(curdir[curlib]>=total_dirs)
  785.     curdir[curlib]=0;
  786. #endif
  787.  
  788. if(usrgrps)
  789.     cursubnum=usrsub[curgrp][cursub[curgrp]];        /* Used for ARS */
  790. else
  791.     cursubnum=INVALID_SUB;
  792. if(usrlibs) {
  793.     curdirnum=usrdir[curlib][curdir[curlib]];        /* Used for ARS */
  794.     path=dir[usrdir[curlib][curdir[curlib]]]->path; }
  795. else {
  796.     curdirnum=INVALID_DIR;
  797.     path=nulstr; }
  798. now=time(NULL);
  799.  
  800. if(csi->ip>=csi->cs+csi->length)
  801.     return(1);
  802.  
  803. //lprintf("%04X: %02X ",(uint)(csi->ip-csi->cs),*csi->ip);
  804.  
  805. if(*csi->ip>=CS_FUNCTIONS)
  806.     return(exec_function(csi));
  807.  
  808. /**********************************************/
  809. /* Miscellaneous variable length instructions */
  810. /**********************************************/
  811.  
  812. if(*csi->ip>=CS_MISC)
  813.     return(exec_misc(csi,path));
  814.  
  815. /********************************/
  816. /* ASCIIZ argument instructions */
  817. /********************************/
  818.  
  819. if(*csi->ip>=CS_ASCIIZ) {
  820.     switch(*(csi->ip++)) {
  821.         case CS_STR_FUNCTION:
  822.             switch(*(csi->ip++)) {
  823.                 case CS_LOGIN:
  824.                     csi->logic=login(csi->str,csi->ip);
  825.                     break;
  826.                 case CS_LOAD_TEXT:
  827.                     csi->logic=LOGIC_FALSE;
  828.                     for(i=0;i<TOTAL_TEXT;i++)
  829.                         if(text[i]!=text_sav[i]) {
  830.                             if(text[i]!=nulstr)
  831.                                 FREE(text[i]);
  832.                             text[i]=text_sav[i]; }
  833.                     sprintf(str,"%s%s.DAT"
  834.                         ,ctrl_dir,cmdstr(csi->ip,path,csi->str,buf));
  835.                     if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
  836.                         errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
  837.                         break; }
  838.                     for(i=0;i<TOTAL_TEXT && !feof(stream);i++) {
  839.                         if((text[i]=readtext((long *)NULL,stream))==NULL) {
  840.                             i--;
  841.                             continue; }
  842.                         if(!strcmp(text[i],text_sav[i])) {    /* If identical */
  843.                             FREE(text[i]);                    /* Don't alloc */
  844.                             text[i]=text_sav[i]; }
  845.                         else if(text[i][0]==0) {
  846.                             FREE(text[i]);
  847.                             text[i]=nulstr; } }
  848.                     if(i<TOTAL_TEXT) {
  849.                         fclose(stream);
  850.                         errormsg(WHERE,ERR_READ,str,TOTAL_TEXT);
  851.                         break; }
  852.                     fclose(stream);
  853.                     csi->logic=LOGIC_TRUE;
  854.                     break;
  855.                 default:
  856.                     errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  857.                     break; }
  858.             while(*(csi->ip++));     /* Find NULL */
  859.             return(0);
  860.         case CS_LOG:
  861.             log(cmdstr(csi->ip,path,csi->str,buf));
  862.             break;
  863.         case CS_GETCMD:
  864.             csi->cmd=getkeys(csi->ip,0);
  865.             if((char)csi->cmd==-1)
  866.                 csi->cmd=3;
  867.             break;
  868.         case CS_CMDSTR:
  869.             if(stricmp(csi->str,csi->ip)) {
  870.                 while(*(csi->ip++));        /* Find NULL */
  871.                 skipto(csi,CS_END_CMD);
  872.                 csi->ip++;
  873.                 return(0); }
  874.             break;
  875.         case CS_CMDKEYS:
  876.             for(i=0;csi->ip[i];i++)
  877.                 if(csi->cmd==csi->ip[i])
  878.                     break;
  879.             if(!csi->ip[i]) {
  880.                 while(*(csi->ip++));        /* Find NULL */
  881.                 skipto(csi,CS_END_CMD);
  882.                 csi->ip++;
  883.                 return(0); }
  884.             break;
  885.         case CS_GET_TEMPLATE:
  886.             gettmplt(csi->str,csi->ip,K_LINE);
  887.             if(sys_status&SS_ABORT)
  888.                 csi->str[0]=0;
  889.             csi->cmd=csi->str[0];
  890.             break;
  891.         case CS_TRASHCAN:
  892.             csi->logic=!trashcan(csi->str,csi->ip);
  893.             break;
  894.         case CS_CREATE_SIF:
  895.             create_sif_dat(csi->ip,csi->str);
  896.             break;
  897.         case CS_READ_SIF:
  898.             read_sif_dat(csi->ip,csi->str);
  899.             break;
  900.         case CS_MNEMONICS:
  901.             mnemonics(csi->ip);
  902.             break;
  903.         case CS_PRINT:
  904.             putmsg(cmdstr(csi->ip,path,csi->str,buf),P_SAVEATR|P_NOABORT);
  905.             break;
  906.         case CS_PRINT_LOCAL:
  907.             lputs(cmdstr(csi->ip,path,csi->str,buf));
  908.             break;
  909.         case CS_PRINT_REMOTE:
  910.             putcom(cmdstr(csi->ip,path,csi->str,buf));
  911.             break;
  912.         case CS_PRINTFILE:
  913.             printfile(cmdstr(csi->ip,path,csi->str,buf),P_SAVEATR);
  914.             break;
  915.         case CS_PRINTFILE_REMOTE:
  916.             if(online!=ON_REMOTE || !(console&CON_R_ECHO))
  917.                 break;
  918.             console&=~CON_L_ECHO;
  919.             printfile(cmdstr(csi->ip,path,csi->str,buf),P_SAVEATR);
  920.             console|=CON_L_ECHO;
  921.             break;
  922.         case CS_PRINTFILE_LOCAL:
  923.             if(!(console&CON_L_ECHO))
  924.                 break;
  925.             console&=~CON_R_ECHO;
  926.             printfile(cmdstr(csi->ip,path,csi->str,buf),P_SAVEATR);
  927.             console|=CON_R_ECHO;
  928.             break;
  929.         case CS_CHKFILE:
  930.             csi->logic=!fexist(cmdstr(csi->ip,path,csi->str,buf));
  931.             break;
  932.         case CS_EXEC:
  933.             external(cmdstr(csi->ip,path,csi->str,buf),0);
  934.             break;
  935.         case CS_EXEC_INT:
  936.             external(cmdstr(csi->ip,path,csi->str,buf),EX_OUTR|EX_INR|EX_OUTL);
  937.             break;
  938.         case CS_EXEC_XTRN:
  939.             for(i=0;i<total_xtrns;i++)
  940.                 if(!stricmp(xtrn[i]->code,csi->ip))
  941.                     break;
  942.             if(i<total_xtrns)
  943.                 exec_xtrn(i);
  944.             break;
  945.         case CS_EXEC_BIN:
  946.             exec_bin(cmdstr(csi->ip,path,csi->str,buf),csi);
  947.             break;
  948.         case CS_YES_NO:
  949.             csi->logic=!yesno(cmdstr(csi->ip,path,csi->str,buf));
  950.             break;
  951.         case CS_NO_YES:
  952.             csi->logic=!noyes(cmdstr(csi->ip,path,csi->str,buf));
  953.             break;
  954.         case CS_MENU:
  955.             menu(cmdstr(csi->ip,path,csi->str,buf));
  956.             break;
  957.         case CS_SETSTR:
  958.             strcpy(csi->str,cmdstr(csi->ip,path,csi->str,buf));
  959.             break;
  960.         case CS_SET_MENU_DIR:
  961.             cmdstr(csi->ip,path,csi->str,menu_dir);
  962.             break;
  963.         case CS_SET_MENU_FILE:
  964.             cmdstr(csi->ip,path,csi->str,menu_file);
  965.             break;
  966.         case CS_COMPARE_STR:
  967.             csi->logic=stricmp(csi->str,cmdstr(csi->ip,path,csi->str,buf));
  968.             break;
  969.         case CS_COMPARE_KEYS:
  970.             for(i=0;csi->ip[i];i++)
  971.                 if(csi->cmd==csi->ip[i])
  972.                     break;
  973.             if(csi->ip[i])
  974.                 csi->logic=LOGIC_TRUE;
  975.             else
  976.                 csi->logic=LOGIC_FALSE;
  977.             break;
  978.         case CS_COMPARE_WORD:
  979.             csi->logic=strnicmp(csi->str,csi->ip,strlen(csi->ip));
  980.             break;
  981.         default:
  982.             errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  983.             break; }
  984.     while(*(csi->ip++));     /* Find NULL */
  985.     return(0); }
  986.  
  987. if(*csi->ip>=CS_THREE_BYTE) {
  988.     switch(*(csi->ip++)) {
  989.         case CS_THREE_MORE_BYTES:
  990.             switch(*(csi->ip++)) {
  991.                 }
  992.             errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  993.             return(0);
  994.         case CS_GOTO:
  995.             csi->ip=csi->cs+*((ushort *)(csi->ip));
  996.             return(0);
  997.         case CS_CALL:
  998.             csi->ret[csi->rets++]=csi->ip+2;
  999.             csi->ip=csi->cs+*((ushort *)(csi->ip));
  1000.             return(0);
  1001.         case CS_MSWAIT:
  1002.             mswait(*(ushort *)csi->ip);
  1003.             csi->ip+=2;
  1004.             return(0);
  1005.         case CS_TOGGLE_NODE_MISC:
  1006.             getnodedat(node_num,&thisnode,1);
  1007.             thisnode.misc^=*(ushort *)csi->ip;
  1008.             csi->ip+=2;
  1009.             putnodedat(node_num,thisnode);
  1010.             return(0);
  1011.         case CS_COMPARE_NODE_MISC:
  1012.             getnodedat(node_num,&thisnode,0);
  1013.             if((thisnode.misc&*(ushort *)csi->ip)==*(ushort *)csi->ip)
  1014.                 csi->logic=LOGIC_TRUE;
  1015.             else
  1016.                 csi->logic=LOGIC_FALSE;
  1017.             csi->ip+=2;
  1018.             return(0);
  1019.         case CS_ADJUST_USER_CREDITS:
  1020.             i=*(short *)csi->ip;
  1021.             l=i*1024L;
  1022.             if(l<0)
  1023.                 subtract_cdt(-l);
  1024.             else
  1025.                 useron.cdt=adjustuserrec(useron.number,U_CDT,10,l);
  1026.             csi->ip+=2;
  1027.             return(0);
  1028.         case CS_ADJUST_USER_MINUTES:
  1029.             i=*(short *)csi->ip;
  1030.             useron.min=adjustuserrec(useron.number,U_MIN,10,i);
  1031.             csi->ip+=2;
  1032.             return(0);
  1033.         case CS_GETNUM:
  1034.             i=*(short *)csi->ip;
  1035.             csi->ip+=2;
  1036.             l=getnum(i);
  1037.             if(l<=0) {
  1038.                 csi->str[0]=0;
  1039.                 csi->logic=LOGIC_FALSE; }
  1040.             else {
  1041.                 sprintf(csi->str,"%lu",l);
  1042.                 csi->logic=LOGIC_TRUE; }
  1043.             return(0);
  1044.  
  1045.         case CS_TOGGLE_USER_FLAG:
  1046.             i=*(csi->ip++);
  1047.             ch=*(csi->ip++);
  1048.             switch(i) {
  1049.                 case '1':
  1050.                     useron.flags1^=FLAG(ch);
  1051.                     putuserrec(useron.number,U_FLAGS1,8
  1052.                         ,ultoa(useron.flags1,tmp,16));
  1053.                     break;
  1054.                 case '2':
  1055.                     useron.flags2^=FLAG(ch);
  1056.                     putuserrec(useron.number,U_FLAGS2,8
  1057.                         ,ultoa(useron.flags2,tmp,16));
  1058.                     break;
  1059.                 case '3':
  1060.                     useron.flags3^=FLAG(ch);
  1061.                     putuserrec(useron.number,U_FLAGS3,8
  1062.                         ,ultoa(useron.flags3,tmp,16));
  1063.                     break;
  1064.                 case '4':
  1065.                     useron.flags4^=FLAG(ch);
  1066.                     putuserrec(useron.number,U_FLAGS4,8
  1067.                         ,ultoa(useron.flags4,tmp,16));
  1068.                     break;
  1069.                 case 'R':
  1070.                     useron.rest^=FLAG(ch);
  1071.                     putuserrec(useron.number,U_REST,8
  1072.                         ,ultoa(useron.rest,tmp,16));
  1073.                     break;
  1074.                 case 'E':
  1075.                     useron.exempt^=FLAG(ch);
  1076.                     putuserrec(useron.number,U_EXEMPT,8
  1077.                         ,ultoa(useron.exempt,tmp,16));
  1078.                     break;
  1079.                 default:
  1080.                     errormsg(WHERE,ERR_CHK,"user flag type",*(csi->ip-2));
  1081.                     return(0); }
  1082.             statusline();
  1083.             return(0);
  1084.         case CS_REVERT_TEXT:
  1085.             i=*(ushort *)csi->ip;
  1086.             csi->ip+=2;
  1087.             if((ushort)i==0xffff) {
  1088.                 for(i=0;i<TOTAL_TEXT;i++) {
  1089.                     if(text[i]!=text_sav[i] && text[i]!=nulstr)
  1090.                         FREE(text[i]);
  1091.                     text[i]=text_sav[i]; }
  1092.                 return(0); }
  1093.             i--;
  1094.             if(i>=TOTAL_TEXT) {
  1095.                 errormsg(WHERE,ERR_CHK,"revert text #",i);
  1096.                 return(0); }
  1097.             if(text[i]!=text_sav[i] && text[i]!=nulstr)
  1098.                 FREE(text[i]);
  1099.             text[i]=text_sav[i];
  1100.             return(0);
  1101.         default:
  1102.             errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  1103.             return(0); } }
  1104.  
  1105. if(*csi->ip>=CS_TWO_BYTE) {
  1106.     switch(*(csi->ip++)) {
  1107.         case CS_TWO_MORE_BYTES:
  1108.             switch(*(csi->ip++)) {
  1109.                 case CS_USER_EVENT:
  1110.                     user_event(*(csi->ip++));
  1111.                     return(0);
  1112.                 }
  1113.             errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  1114.             return(0);
  1115.         case CS_SETLOGIC:
  1116.             csi->logic=*csi->ip++;
  1117.             return(0);
  1118.         case CS_CMDKEY:
  1119.             if( ((*csi->ip)==CS_DIGIT && isdigit(csi->cmd))
  1120.                 || ((*csi->ip)==CS_EDIGIT && csi->cmd&0x80
  1121.                 && isdigit(csi->cmd&0x7f))) {
  1122.                 csi->ip++;
  1123.                 return(0); }
  1124.             if(csi->cmd!=*csi->ip) {
  1125.                 csi->ip++;
  1126.                 skipto(csi,CS_END_CMD); }     /* skip code */
  1127.             csi->ip++;                        /* skip key */
  1128.             return(0);
  1129.         case CS_NODE_ACTION:
  1130.             action=*csi->ip++;
  1131.             return(0);
  1132.         case CS_NODE_STATUS:
  1133.             getnodedat(node_num,&thisnode,1);
  1134.             thisnode.status=*csi->ip++;
  1135.             putnodedat(node_num,thisnode);
  1136.             return(0);
  1137.         case CS_GETSTR:
  1138.             csi->logic=LOGIC_TRUE;
  1139.             getstr(csi->str,*csi->ip++,0);
  1140.             if(sys_status&SS_ABORT) {
  1141.                 csi->str[0]=0;
  1142.                 csi->logic=LOGIC_FALSE; }
  1143.             if(csi->str[0]=='/' && csi->str[1])
  1144.                 csi->cmd=csi->str[1]|0x80;
  1145.             else
  1146.                 csi->cmd=csi->str[0];
  1147.             return(0);
  1148.         case CS_GETLINE:
  1149.             getstr(csi->str,*csi->ip++,K_LINE);
  1150.             if(sys_status&SS_ABORT)
  1151.                 csi->str[0]=0;
  1152.             if(csi->str[0]=='/' && csi->str[1])
  1153.                 csi->cmd=csi->str[1]|0x80;
  1154.             else
  1155.                 csi->cmd=csi->str[0];
  1156.             return(0);
  1157.         case CS_GETSTRUPR:
  1158.             getstr(csi->str,*csi->ip++,K_UPPER);
  1159.             if(sys_status&SS_ABORT)
  1160.                 csi->str[0]=0;
  1161.             if(csi->str[0]=='/' && csi->str[1])
  1162.                 csi->cmd=csi->str[1]|0x80;
  1163.             else
  1164.                 csi->cmd=csi->str[0];
  1165.             return(0);
  1166.         case CS_GETNAME:
  1167.             getstr(csi->str,*csi->ip++,K_UPRLWR);
  1168.             if(sys_status&SS_ABORT)
  1169.                 csi->str[0]=0;
  1170.             return(0);
  1171.         case CS_SHIFT_STR:
  1172.             if(strlen(csi->str)>=*csi->ip)
  1173.                 memmove(csi->str,csi->str+(*csi->ip)
  1174.                     ,strlen(csi->str)+1);
  1175.             csi->ip++;
  1176.             return(0);
  1177.         case CS_COMPARE_KEY:
  1178.             if( ((*csi->ip)==CS_DIGIT && isdigit(csi->cmd))
  1179.                 || ((*csi->ip)==CS_EDIGIT && csi->cmd&0x80
  1180.                 && isdigit(csi->cmd&0x7f))) {
  1181.                 csi->ip++;
  1182.                 csi->logic=LOGIC_TRUE; }
  1183.             else {
  1184.                 if(csi->cmd==*(csi->ip++))
  1185.                     csi->logic=LOGIC_TRUE;
  1186.                 else
  1187.                     csi->logic=LOGIC_FALSE; }
  1188.             return(0);
  1189.         case CS_SET_USER_LEVEL:
  1190.             useron.level=*(csi->ip++);
  1191.             putuserrec(useron.number,U_LEVEL,2,itoa(useron.level,tmp,10));
  1192.             statusline();
  1193.             return(0);
  1194.         case CS_SET_USER_STRING:
  1195.             csi->logic=LOGIC_FALSE;
  1196.             if(!csi->str[0]) {
  1197.                 csi->ip++;
  1198.                 return(0); }
  1199.             switch(*(csi->ip++)) {
  1200.                 case USER_STRING_ALIAS:
  1201.                     if(!isalpha(csi->str[0]) || trashcan(csi->str,"NAME"))
  1202.                         break;
  1203.                     i=matchuser(csi->str);
  1204.                     if(i && i!=useron.number)
  1205.                         break;
  1206.                     sprintf(useron.alias,"%.*s",LEN_ALIAS,csi->str);
  1207.                     putuserrec(useron.number,U_ALIAS,LEN_ALIAS,useron.alias);
  1208.                     putusername(useron.number,useron.alias);
  1209.                     csi->logic=LOGIC_TRUE;
  1210.                     break;
  1211.                 case USER_STRING_REALNAME:
  1212.                     if(trashcan(csi->str,"NAME"))
  1213.                         break;
  1214.                     if(uq&UQ_DUPREAL
  1215.                         && userdatdupe(useron.number,U_NAME,LEN_NAME
  1216.                         ,csi->str,0))
  1217.                         break;
  1218.                     sprintf(useron.name,"%.*s",LEN_NAME,csi->str);
  1219.                     putuserrec(useron.number,U_NAME,LEN_NAME
  1220.                         ,useron.name);
  1221.                     csi->logic=LOGIC_TRUE;
  1222.                     break;
  1223.                 case USER_STRING_HANDLE:
  1224.                     if(trashcan(csi->str,"NAME"))
  1225.                         break;
  1226.                     if(uq&UQ_DUPHAND
  1227.                         && userdatdupe(useron.number,U_HANDLE,LEN_HANDLE
  1228.                         ,csi->str,0))
  1229.                         break;
  1230.                     sprintf(useron.handle,"%.*s",LEN_HANDLE,csi->str);
  1231.                     putuserrec(useron.number,U_HANDLE,LEN_HANDLE
  1232.                         ,useron.handle);
  1233.                     csi->logic=LOGIC_TRUE;
  1234.                     break;
  1235.                 case USER_STRING_COMPUTER:
  1236.                     sprintf(useron.comp,"%.*s",LEN_COMP,csi->str);
  1237.                     putuserrec(useron.number,U_COMP,LEN_COMP
  1238.                         ,useron.comp);
  1239.                     csi->logic=LOGIC_TRUE;
  1240.                     break;
  1241.                 case USER_STRING_NOTE:
  1242.                     sprintf(useron.note,"%.*s",LEN_NOTE,csi->str);
  1243.                     putuserrec(useron.number,U_NOTE,LEN_NOTE
  1244.                         ,useron.note);
  1245.                     csi->logic=LOGIC_TRUE;
  1246.                     break;
  1247.                 case USER_STRING_ADDRESS:
  1248.                     sprintf(useron.address,"%.*s",LEN_ADDRESS,csi->str);
  1249.                     putuserrec(useron.number,U_ADDRESS,LEN_ADDRESS
  1250.                         ,useron.address);
  1251.                     csi->logic=LOGIC_TRUE;
  1252.                     break;
  1253.                 case USER_STRING_LOCATION:
  1254.                     sprintf(useron.location,"%.*s",LEN_LOCATION,csi->str);
  1255.                     putuserrec(useron.number,U_LOCATION,LEN_LOCATION
  1256.                         ,useron.location);
  1257.                     csi->logic=LOGIC_TRUE;
  1258.                     break;
  1259.                 case USER_STRING_ZIPCODE:
  1260.                     sprintf(useron.zipcode,"%.*s",LEN_ZIPCODE,csi->str);
  1261.                     putuserrec(useron.number,U_ZIPCODE,LEN_ZIPCODE
  1262.                         ,useron.zipcode);
  1263.                     csi->logic=LOGIC_TRUE;
  1264.                     break;
  1265.                 case USER_STRING_PASSWORD:
  1266.                     sprintf(useron.pass,"%.*s",LEN_PASS,csi->str);
  1267.                     putuserrec(useron.number,U_PASS,LEN_PASS
  1268.                         ,useron.pass);
  1269.                     csi->logic=LOGIC_TRUE;
  1270.                     break;
  1271.                 case USER_STRING_BIRTHDAY:
  1272.                     if(!getage(csi->str))
  1273.                         break;
  1274.                     sprintf(useron.birth,"%.*s",LEN_BIRTH,csi->str);
  1275.                     putuserrec(useron.number,U_BIRTH,LEN_BIRTH
  1276.                         ,useron.birth);
  1277.                     csi->logic=LOGIC_TRUE;
  1278.                     break;
  1279.                 case USER_STRING_PHONE:
  1280.                     if(trashcan(csi->str,"PHONE"))
  1281.                         break;
  1282.                     sprintf(useron.phone,"%.*s",LEN_PHONE,csi->str);
  1283.                     putuserrec(useron.number,U_PHONE,LEN_PHONE
  1284.                         ,useron.phone);
  1285.                     csi->logic=LOGIC_TRUE;
  1286.                     break;
  1287.                 case USER_STRING_MODEM:
  1288.                     sprintf(useron.modem,"%.*s",LEN_MODEM,csi->str);
  1289.                     putuserrec(useron.number,U_MODEM,LEN_MODEM
  1290.                         ,useron.phone);
  1291.                     csi->logic=LOGIC_TRUE;
  1292.                     break;
  1293.                 case USER_STRING_COMMENT:
  1294.                     sprintf(useron.comment,"%.*s",LEN_COMMENT,csi->str);
  1295.                     putuserrec(useron.number,U_COMMENT,LEN_COMMENT
  1296.                         ,useron.comment);
  1297.                     csi->logic=LOGIC_TRUE;
  1298.                     break;
  1299.                 default:
  1300.                     errormsg(WHERE,ERR_CHK,"user string type",*(csi->ip-1));
  1301.                     return(0); }
  1302.             statusline();
  1303.             return(0);
  1304.         default:
  1305.             errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  1306.             return(0); } }
  1307.  
  1308.  
  1309. /*********************************/
  1310. /* Single Byte Instrcutions ONLY */
  1311. /*********************************/
  1312.  
  1313. switch(*(csi->ip++)) {
  1314.     case CS_ONE_MORE_BYTE:                 /* Just one MORE byte */
  1315.         switch(*(csi->ip++)) {
  1316.             case CS_OFFLINE:
  1317.                 csi->misc|=CS_OFFLINE_EXEC;
  1318.                 return(0);
  1319.             case CS_ONLINE:
  1320.                 csi->misc&=~CS_OFFLINE_EXEC;
  1321.                 return(0);
  1322.             case CS_NEWUSER:
  1323.                 newuser();
  1324.                 return(0);
  1325.             case CS_LOGON:
  1326.                 if(logon())
  1327.                     csi->logic=LOGIC_TRUE;
  1328.                 else
  1329.                     csi->logic=LOGIC_FALSE;
  1330.                 return(0);
  1331.             case CS_LOGOUT:
  1332.                 logout();
  1333.                 return(0);
  1334.             case CS_EXIT:
  1335.                 return(1);
  1336.             default:
  1337.                 errormsg(WHERE,ERR_CHK,"one byte extended function"
  1338.                     ,*(csi->ip-1));
  1339.                 return(0); }
  1340.     case CS_CRLF:
  1341.         CRLF;
  1342.         return(0);
  1343.     case CS_CLS:
  1344.         CLS;
  1345.         return(0);
  1346.     case CS_PAUSE:
  1347.         pause();
  1348.         return(0);
  1349.     case CS_PAUSE_RESET:
  1350.         lncntr=0;
  1351.         return(0);
  1352.     case CS_GETLINES:
  1353.         getlines();
  1354.         return(0);
  1355.     case CS_HANGUP:
  1356.         hangup();
  1357.         return(0);
  1358.     case CS_LOGKEY:
  1359.         logch(csi->cmd,0);
  1360.         return(0);
  1361.     case CS_LOGKEY_COMMA:
  1362.         logch(csi->cmd,1);
  1363.         return(0);
  1364.     case CS_LOGSTR:
  1365.         log(csi->str);
  1366.         return(0);
  1367.     case CS_CHKSYSPASS:
  1368.         csi->logic=!chksyspass(0);
  1369.         return(0);
  1370.     case CS_PUT_NODE:
  1371.         getnodedat(node_num,&thisnode,1);
  1372.         putnodedat(node_num,thisnode);
  1373.         return(0);
  1374.     case CS_SYNC:
  1375.         SYNC;
  1376.         return(0);
  1377.     case CS_ASYNC:
  1378.         ASYNC;
  1379.         return(0);
  1380.     case CS_RIOSYNC:
  1381.         RIOSYNC(0);
  1382.         return(0);
  1383.     case CS_GETTIMELEFT:
  1384.         gettimeleft();
  1385.         return(0);
  1386.     case CS_RETURN:
  1387.         if(!csi->rets)
  1388.             return(1);
  1389.         csi->ip=csi->ret[--csi->rets];
  1390.         return(0);
  1391.     case CS_GETKEY:
  1392.         csi->cmd=getkey(K_UPPER);
  1393.         return(0);
  1394.     case CS_INKEY:
  1395.         csi->cmd=toupper(inkey(K_GETSTR));
  1396.         if(csi->cmd)
  1397.             csi->logic=LOGIC_TRUE;
  1398.         else
  1399.             csi->logic=LOGIC_FALSE;
  1400.         return(0);
  1401.     case CS_GETKEYE:
  1402.         csi->cmd=getkey(K_UPPER);
  1403.         if(csi->cmd=='/') {
  1404.             outchar('/');
  1405.             csi->cmd=getkey(K_UPPER);
  1406.             csi->cmd|=0x80; }
  1407.         return(0);
  1408.     case CS_GETFILESPEC:
  1409.         if(getfilespec(csi->str))
  1410.             csi->logic=LOGIC_TRUE;
  1411.         else
  1412.             csi->logic=LOGIC_FALSE;
  1413.         return(0);
  1414.     case CS_SAVELINE:
  1415.         SAVELINE;
  1416.         return(0);
  1417.     case CS_RESTORELINE:
  1418.         RESTORELINE;
  1419.         return(0);
  1420.     case CS_SELECT_SHELL:
  1421.         csi->logic=LOGIC_TRUE;
  1422.         for(i=0;i<total_shells;i++)
  1423.             uselect(1,i,"Command Shell",shell[i]->name,shell[i]->ar);
  1424.         if((i=uselect(0,useron.shell,0,0,0))>=0) {
  1425.             useron.shell=i;
  1426.             putuserrec(useron.number,U_SHELL,8,shell[i]->code); }
  1427.         else
  1428.             csi->logic=LOGIC_FALSE;
  1429.         return(0);
  1430.     case CS_SET_SHELL:
  1431.         csi->logic=LOGIC_TRUE;
  1432.         for(i=0;i<total_shells;i++)
  1433.             if(!stricmp(csi->str,shell[i]->code)
  1434.                 && chk_ar(shell[i]->ar,useron))
  1435.                 break;
  1436.         if(i<total_shells) {
  1437.             useron.shell=i;
  1438.             putuserrec(useron.number,U_SHELL,8,shell[i]->code); }
  1439.         else
  1440.             csi->logic=LOGIC_FALSE;
  1441.         return(0);
  1442.  
  1443.     case CS_SELECT_EDITOR:
  1444.         csi->logic=LOGIC_TRUE;
  1445.         for(i=0;i<total_xedits;i++)
  1446.             uselect(1,i,"External Editor",xedit[i]->name,xedit[i]->ar);
  1447.         if(useron.xedit) useron.xedit--;
  1448.         if((i=uselect(0,useron.xedit,0,0,0))>=0) {
  1449.             useron.xedit=i+1;
  1450.             putuserrec(useron.number,U_XEDIT,8,xedit[i]->code); }
  1451.         else
  1452.             csi->logic=LOGIC_FALSE;
  1453.         return(0);
  1454.     case CS_SET_EDITOR:
  1455.         csi->logic=LOGIC_TRUE;
  1456.         for(i=0;i<total_xedits;i++)
  1457.             if(!stricmp(csi->str,xedit[i]->code)
  1458.                 && chk_ar(xedit[i]->ar,useron))
  1459.                 break;
  1460.         if(i<total_xedits) {
  1461.             useron.xedit=i+1;
  1462.             putuserrec(useron.number,U_XEDIT,8,xedit[i]->code); }
  1463.         else
  1464.             csi->logic=LOGIC_FALSE;
  1465.         return(0);
  1466.  
  1467.     case CS_CLEAR_ABORT:
  1468.         sys_status&=~SS_ABORT;
  1469.         return(0);
  1470.     case CS_FINDUSER:
  1471.         i=finduser(csi->str);
  1472.         if(i) {
  1473.             csi->logic=LOGIC_TRUE;
  1474.             username(i,csi->str); }
  1475.         else
  1476.             csi->logic=LOGIC_FALSE;
  1477.         return(0);
  1478.     case CS_UNGETKEY:
  1479.         ungetkey(csi->cmd&0x7f);
  1480.         return(0);
  1481.     case CS_UNGETSTR:
  1482.         j=strlen(csi->str);
  1483.         for(i=0;i<j;i++)
  1484.             ungetkey(csi->str[i]);
  1485.         return(0);
  1486.     case CS_PRINTKEY:
  1487.         if((csi->cmd&0x7f)>=SP)
  1488.             outchar(csi->cmd&0x7f);
  1489.         return(0);
  1490.     case CS_PRINTSTR:
  1491.         putmsg(csi->str,P_SAVEATR|P_NOABORT);
  1492.         return(0);
  1493.     case CS_CMD_HOME:
  1494.         csi->cmdret[csi->cmdrets++]=(csi->ip-1);
  1495.         return(0);
  1496.     case CS_END_CMD:
  1497.         if(csi->cmdrets)
  1498.             csi->ip=csi->cmdret[--csi->cmdrets];
  1499. /*                                                    Removed 06/07/95
  1500.         else
  1501.             errormsg(WHERE,ERR_CHK,"misplaced end_cmd",(csi->ip-csi->cs)-1);
  1502. */
  1503.         return(0);
  1504.     case CS_CMD_POP:
  1505.         if(csi->cmdrets)
  1506.             csi->cmdrets--;
  1507.         return(0);
  1508.     case CS_IF_TRUE:
  1509.         if(csi->logic!=LOGIC_TRUE) {
  1510.             skipto(csi,CS_ELSEORENDIF);
  1511.             csi->ip++; }
  1512.         return(0);
  1513.     case CS_IF_GREATER:
  1514.         if(csi->logic!=LOGIC_GREATER) {
  1515.             skipto(csi,CS_ELSEORENDIF);
  1516.             csi->ip++; }
  1517.         return(0);
  1518.     case CS_IF_GREATER_OR_EQUAL:
  1519.         if(csi->logic!=LOGIC_GREATER && csi->logic!=LOGIC_EQUAL) {
  1520.             skipto(csi,CS_ELSEORENDIF);
  1521.             csi->ip++; }
  1522.         return(0);
  1523.     case CS_IF_LESS:
  1524.         if(csi->logic!=LOGIC_LESS) {
  1525.             skipto(csi,CS_ELSEORENDIF);
  1526.             csi->ip++; }
  1527.         return(0);
  1528.     case CS_IF_LESS_OR_EQUAL:
  1529.         if(csi->logic!=LOGIC_LESS && csi->logic!=LOGIC_EQUAL) {
  1530.             skipto(csi,CS_ELSEORENDIF);
  1531.             csi->ip++; }
  1532.         return(0);
  1533.     case CS_IF_FALSE:
  1534.         if(csi->logic==LOGIC_TRUE) {
  1535.             skipto(csi,CS_ELSEORENDIF);
  1536.             csi->ip++; }
  1537.         return(0);
  1538.     case CS_ELSE:
  1539.         skipto(csi,CS_ENDIF);
  1540.         csi->ip++;
  1541.         return(0);
  1542.     case CS_END_CASE:
  1543.         skipto(csi,CS_END_SWITCH);
  1544.         csi->misc&=~CS_IN_SWITCH;
  1545.         csi->ip++;
  1546.         return(0);
  1547.     case CS_DEFAULT:
  1548.     case CS_END_SWITCH:
  1549.         csi->misc&=~CS_IN_SWITCH;
  1550.         return(0);
  1551.     case CS_ENDIF:
  1552.         return(0);
  1553.     default:
  1554.         errormsg(WHERE,ERR_CHK,"shell instruction",*(csi->ip-1));
  1555.         return(0); }
  1556. }
  1557.  
  1558.