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