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