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