![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chk_ar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to chk_ar.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "CHK_AR.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: int ar_exp(char **ptrptr, user_t user)
8: {
9: uint len,true=1,not,or,equal,artype=AR_LEVEL,n,i,age;
10: ulong l;
11: struct tm *gm;
12:
13: for(;(**ptrptr);(*ptrptr)++) {
14:
15: if((**ptrptr)==AR_ENDNEST)
16: break;
17:
18: not=or=equal=0;
19:
20: if((**ptrptr)==AR_OR) {
21: or=1;
22: (*ptrptr)++; }
23:
24: if((**ptrptr)==AR_NOT) {
25: not=1;
26: (*ptrptr)++; }
27:
28: if((**ptrptr)==AR_EQUAL) {
29: equal=1;
30: (*ptrptr)++; }
31:
32: if((true && or) || (!true && !or))
33: break;
34:
35: if((**ptrptr)==AR_BEGNEST) {
36: (*ptrptr)++;
37: if(ar_exp(ptrptr,user))
38: true=!not;
39: else
40: true=not;
41: while((**ptrptr)!=AR_ENDNEST && (**ptrptr)) /* in case of early exit */
42: (*ptrptr)++;
43: if(!(**ptrptr))
44: break;
45: continue; }
46:
47: artype=(**ptrptr);
48: switch(artype) {
49: case AR_ANSI: /* No arguments */
50: case AR_RIP:
51: case AR_WIP:
52: case AR_LOCAL:
53: case AR_EXPERT:
54: case AR_SYSOP:
55: case AR_QUIET:
56: case AR_OS2:
57: case AR_DOS:
58: break;
59: default:
60: (*ptrptr)++;
61: break; }
62:
63: n=(**ptrptr);
64: i=(*(short *)*ptrptr);
65: switch(artype) {
66: case AR_LEVEL:
67: if((equal && user.level!=n) || (!equal && user.level<n))
68: true=not;
69: else
70: true=!not;
71: if(!true) {
72: noaccess_str=text[NoAccessLevel];
73: noaccess_val=n; }
74: break;
75: case AR_AGE:
76: age=getage(user.birth);
77: if((equal && age!=n) || (!equal && age<n))
78: true=not;
79: else
80: true=!not;
81: if(!true) {
82: noaccess_str=text[NoAccessAge];
83: noaccess_val=n; }
84: break;
85: case AR_BPS:
86: if((equal && cur_rate!=i) || (!equal && cur_rate<i))
87: true=not;
88: else
89: true=!not;
90: (*ptrptr)++;
91: if(!true) {
92: noaccess_str=text[NoAccessBPS];
93: noaccess_val=i; }
94: break;
95: case AR_ANSI:
96: if(!(user.misc&ANSI))
97: true=not;
98: else true=!not;
99: break;
100: case AR_RIP:
101: if(!(user.misc&RIP))
102: true=not;
103: else true=!not;
104: break;
105: case AR_WIP:
106: if(!(user.misc&WIP))
107: true=not;
108: else true=!not;
109: break;
110: case AR_OS2:
111: #ifndef __OS2__
112: true=not;
113: #else
114: true=!not;
115: #endif
116: break;
117: case AR_DOS:
118: #ifdef __FLAT__
119: true=not;
120: #else
121: true=!not;
122: #endif
123: break;
124: case AR_EXPERT:
125: if(!(user.misc&EXPERT))
126: true=not;
127: else true=!not;
128: break;
129: case AR_SYSOP:
130: if(!SYSOP)
131: true=not;
132: else true=!not;
133: break;
134: case AR_QUIET:
135: if(thisnode.status!=NODE_QUIET)
136: true=not;
137: else true=!not;
138: break;
139: case AR_LOCAL:
140: if(online!=ON_LOCAL)
141: true=not;
142: else true=!not;
143: break;
144: case AR_DAY:
145: now=time(NULL);
146: gm=localtime(&now); /* Qnet call out based on time */
147: if((equal && gm->tm_wday!=n) || (!equal && gm->tm_wday<n))
148: true=not;
149: else
150: true=!not;
151: if(!true) {
152: noaccess_str=text[NoAccessDay];
153: noaccess_val=n; }
154: break;
155: case AR_CREDIT:
156: l=(ulong)i*1024UL;
157: if((equal && user.cdt+user.freecdt!=l)
158: || (!equal && user.cdt+user.freecdt<l))
159: true=not;
160: else
161: true=!not;
162: (*ptrptr)++;
163: if(!true) {
164: noaccess_str=text[NoAccessCredit];
165: noaccess_val=l; }
166: break;
167: case AR_NODE:
168: if((equal && node_num!=n) || (!equal && node_num<n))
169: true=not;
170: else
171: true=!not;
172: if(!true) {
173: noaccess_str=text[NoAccessNode];
174: noaccess_val=n; }
175: break;
176: case AR_USER:
177: if((equal && user.number!=i) || (!equal && user.number<i))
178: true=not;
179: else
180: true=!not;
181: (*ptrptr)++;
182: if(!true) {
183: noaccess_str=text[NoAccessUser];
184: noaccess_val=i; }
185: break;
186: case AR_GROUP:
187: if((equal
188: && (cursubnum<0 || cursubnum>=total_subs
189: || sub[cursubnum]->grp!=i))
190: || (!equal && cursubnum>=0 && cursubnum<total_subs
191: && sub[cursubnum]->grp<i))
192: true=not;
193: else
194: true=!not;
195: (*ptrptr)++;
196: if(!true) {
197: noaccess_str=text[NoAccessGroup];
198: noaccess_val=i+1; }
199: break;
200: case AR_SUB:
201: if((equal && cursubnum!=i) || (!equal && cursubnum<i))
202: true=not;
203: else
204: true=!not;
205: (*ptrptr)++;
206: if(!true) {
207: noaccess_str=text[NoAccessSub];
208: noaccess_val=i+1; }
209: break;
210: case AR_SUBCODE:
211: if(cursubnum<0 || cursubnum>=total_subs
212: || strcmp(sub[cursubnum]->code,*ptrptr))
213: true=not;
214: else
215: true=!not;
216: while(*(*ptrptr))
217: (*ptrptr)++;
218: if(!true)
219: noaccess_str=text[NoAccessSub];
220: break;
221: case AR_LIB:
222: if((equal
223: && (curdirnum<0 || curdirnum>=total_dirs
224: || dir[curdirnum]->lib!=i))
225: || (!equal && curdirnum>=0 && curdirnum<total_dirs
226: && dir[curdirnum]->lib<i))
227: true=not;
228: else
229: true=!not;
230: (*ptrptr)++;
231: if(!true) {
232: noaccess_str=text[NoAccessLib];
233: noaccess_val=i+1; }
234: break;
235: case AR_DIR:
236: if((equal && curdirnum!=i) || (!equal && curdirnum<i))
237: true=not;
238: else
239: true=!not;
240: (*ptrptr)++;
241: if(!true) {
242: noaccess_str=text[NoAccessDir];
243: noaccess_val=i+1; }
244: break;
245: case AR_DIRCODE:
246: if(curdirnum<0 || curdirnum>=total_dirs
247: || strcmp(dir[curdirnum]->code,*ptrptr))
248: true=not;
249: else
250: true=!not;
251: while(*(*ptrptr))
252: (*ptrptr)++;
253: if(!true)
254: noaccess_str=text[NoAccessSub];
255: break;
256: case AR_EXPIRE:
257: now=time(NULL);
258: if(!user.expire || now+((long)i*24L*60L*60L)>user.expire)
259: true=not;
260: else
261: true=!not;
262: (*ptrptr)++;
263: if(!true) {
264: noaccess_str=text[NoAccessExpire];
265: noaccess_val=i; }
266: break;
267: case AR_RANDOM:
268: n=random(i+1);
269: if((equal && n!=i) || (!equal && n<i))
270: true=not;
271: else
272: true=!not;
273: (*ptrptr)++;
274: break;
275: case AR_LASTON:
276: now=time(NULL);
277: if((now-user.laston)/(24L*60L*60L)<i)
278: true=not;
279: else
280: true=!not;
281: (*ptrptr)++;
282: break;
283: case AR_LOGONS:
284: if((equal && user.logons!=i) || (!equal && user.logons<i))
285: true=not;
286: else
287: true=!not;
288: (*ptrptr)++;
289: break;
290: case AR_MAIN_CMDS:
291: if((equal && main_cmds!=i) || (!equal && main_cmds<i))
292: true=not;
293: else
294: true=!not;
295: (*ptrptr)++;
296: break;
297: case AR_FILE_CMDS:
298: if((equal && xfer_cmds!=i) || (!equal && xfer_cmds<i))
299: true=not;
300: else
301: true=!not;
302: (*ptrptr)++;
303: break;
304: case AR_TLEFT:
305: if(timeleft/60<n)
306: true=not;
307: else
308: true=!not;
309: if(!true) {
310: noaccess_str=text[NoAccessTimeLeft];
311: noaccess_val=n; }
312: break;
313: case AR_TUSED:
314: if((time(NULL)-logontime)/60<n)
315: true=not;
316: else
317: true=!not;
318: if(!true) {
319: noaccess_str=text[NoAccessTimeUsed];
320: noaccess_val=n; }
321: break;
322: case AR_TIME:
323: now=time(NULL);
324: unixtodos(now,&date,&curtime);
325: if((curtime.ti_hour*60)+curtime.ti_min<i)
326: true=not;
327: else
328: true=!not;
329: (*ptrptr)++;
330: if(!true) {
331: noaccess_str=text[NoAccessTime];
332: noaccess_val=i; }
333: break;
334: case AR_PCR:
335: if(user.logons>user.posts
336: && (!user.posts || 100/(user.logons/user.posts)<n))
337: true=not;
338: else
339: true=!not;
340: if(!true) {
341: noaccess_str=text[NoAccessPCR];
342: noaccess_val=n; }
343: break;
344: case AR_UDR: /* up/download byte ratio */
345: l=user.dlb;
346: if(!l) l=1;
347: if(user.dlb>user.ulb
348: && (!user.ulb || 100/(l/user.ulb)<n))
349: true=not;
350: else
351: true=!not;
352: if(!true) {
353: noaccess_str=text[NoAccessUDR];
354: noaccess_val=n; }
355: break;
356: case AR_UDFR: /* up/download file ratio */
357: i=user.dls;
358: if(!i) i=1;
359: if(user.dls>user.uls
360: && (!user.uls || 100/(i/user.uls)<n))
361: true=not;
362: else
363: true=!not;
364: if(!true) {
365: noaccess_str=text[NoAccessUDFR];
366: noaccess_val=n; }
367: break;
368: case AR_FLAG1:
369: if((!equal && !(user.flags1&FLAG(n)))
370: || (equal && user.flags1!=FLAG(n)))
371: true=not;
372: else
373: true=!not;
374: if(!true) {
375: noaccess_str=text[NoAccessFlag1];
376: noaccess_val=n; }
377: break;
378: case AR_FLAG2:
379: if((!equal && !(user.flags2&FLAG(n)))
380: || (equal && user.flags2!=FLAG(n)))
381: true=not;
382: else
383: true=!not;
384: if(!true) {
385: noaccess_str=text[NoAccessFlag2];
386: noaccess_val=n; }
387: break;
388: case AR_FLAG3:
389: if((!equal && !(user.flags3&FLAG(n)))
390: || (equal && user.flags3!=FLAG(n)))
391: true=not;
392: else
393: true=!not;
394: if(!true) {
395: noaccess_str=text[NoAccessFlag3];
396: noaccess_val=n; }
397: break;
398: case AR_FLAG4:
399: if((!equal && !(user.flags4&FLAG(n)))
400: || (equal && user.flags4!=FLAG(n)))
401: true=not;
402: else
403: true=!not;
404: if(!true) {
405: noaccess_str=text[NoAccessFlag4];
406: noaccess_val=n; }
407: break;
408: case AR_REST:
409: if((!equal && !(user.rest&FLAG(n)))
410: || (equal && user.rest!=FLAG(n)))
411: true=not;
412: else
413: true=!not;
414: if(!true) {
415: noaccess_str=text[NoAccessRest];
416: noaccess_val=n; }
417: break;
418: case AR_EXEMPT:
419: if((!equal && !(user.exempt&FLAG(n)))
420: || (equal && user.exempt!=FLAG(n)))
421: true=not;
422: else
423: true=!not;
424: if(!true) {
425: noaccess_str=text[NoAccessExempt];
426: noaccess_val=n; }
427: break;
428: case AR_SEX:
429: if(user.sex!=n)
430: true=not;
431: else
432: true=!not;
433: if(!true) {
434: noaccess_str=text[NoAccessSex];
435: noaccess_val=n; }
436: break; } }
437: return(true);
438: }
439:
440: int chk_ar(char *str, user_t user)
441: {
442: char *p;
443:
444: if(str==NULL)
445: return(1);
446: p=str;
447: return(ar_exp(&p,user));
448: }
449:
450:
451: /****************************************************************************/
452: /* This function fills the usrsub, usrsubs, usrgrps, curgrp, and cursub */
453: /* variables based on the security clearance of the current user (useron) */
454: /****************************************************************************/
455: void getusrsubs()
456: {
457: uint i,j,k,l;
458:
459: for(j=0,i=0;i<total_grps;i++) {
460: if(!chk_ar(grp[i]->ar,useron))
461: continue;
462: for(k=0,l=0;l<total_subs;l++) {
463: if(sub[l]->grp!=i) continue;
464: if(!chk_ar(sub[l]->ar,useron))
465: continue;
466: usrsub[j][k++]=l; }
467: usrsubs[j]=k;
468: if(!k) /* No subs accessible in group */
469: continue;
470: usrgrp[j++]=i; }
471: usrgrps=j;
472: while((curgrp>=usrgrps || !usrsubs[curgrp]) && curgrp) curgrp--;
473: while(cursub[curgrp]>=usrsubs[curgrp] && cursub[curgrp]) cursub[curgrp]--;
474: }
475:
476: /****************************************************************************/
477: /* This function fills the usrdir, usrdirs, usrlibs, curlib, and curdir */
478: /* variables based on the security clearance of the current user (useron) */
479: /****************************************************************************/
480: void getusrdirs()
481: {
482: uint i,j,k,l;
483:
484: if(useron.rest&FLAG('T')) {
485: usrlibs=0;
486: return; }
487: for(j=0,i=0;i<total_libs;i++) {
488: if(!chk_ar(lib[i]->ar,useron))
489: continue;
490: for(k=0,l=0;l<total_dirs;l++) {
491: if(dir[l]->lib!=i) continue;
492: if(!chk_ar(dir[l]->ar,useron))
493: continue;
494: usrdir[j][k++]=l; }
495: usrdirs[j]=k;
496: if(!k) /* No dirs accessible in lib */
497: continue;
498: usrlib[j++]=i; }
499: usrlibs=j;
500: while((curlib>=usrlibs || !usrdirs[curlib]) && curlib) curlib--;
501: while(curdir[curlib]>=usrdirs[curlib] && curdir[curlib]) curdir[curlib]--;
502: }
503:
504: int dir_op(uint dirnum)
505: {
506: return(SYSOP || (dir[dirnum]->op_ar[0] && chk_ar(dir[dirnum]->op_ar,useron)));
507: }
508:
509:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.