![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to exec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to exec.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
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:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.