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