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