Annotation of sbbs/sbbs2/exec.c, revision 1.1

1.1     ! root        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: 

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.