![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chk_ar.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs3|
Return to chk_ar.cpp CVS log | Up to [Synchronet] / sbbs / sbbs3 |
1.1 root 1: /* chk_ar.cpp */
2:
3: /* Synchronet ARS checking routine */
4:
5: /* $Id: chk_ar.cpp,v 1.4 2000/11/16 13:48:42 rswindell Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2000 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This program is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU General Public License for more details: gpl.txt or *
18: * http://www.fsf.org/copyleft/gpl.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include "sbbs.h"
39:
40: bool sbbs_t::ar_exp(uchar **ptrptr, user_t* user)
41: {
42: bool result,not,or,equal;
43: uint i,n,artype,age;
44: ulong l;
45: struct tm * tm;
46:
47: result = true;
48:
49: for(;(**ptrptr);(*ptrptr)++) {
50:
51: if((**ptrptr)==AR_ENDNEST)
52: break;
53:
54: not=or=equal = false;
55:
56: if((**ptrptr)==AR_OR) {
57: or=true;
58: (*ptrptr)++; }
59:
60: if((**ptrptr)==AR_NOT) {
61: not=true;
62: (*ptrptr)++; }
63:
64: if((**ptrptr)==AR_EQUAL) {
65: equal=true;
66: (*ptrptr)++; }
67:
68: if((result && or) || (!result && !or))
69: break;
70:
71: if((**ptrptr)==AR_BEGNEST) {
72: (*ptrptr)++;
73: if(ar_exp(ptrptr,user))
74: result=!not;
75: else
76: result=not;
77: while((**ptrptr)!=AR_ENDNEST && (**ptrptr)) /* in case of early exit */
78: (*ptrptr)++;
79: if(!(**ptrptr))
80: break;
81: continue; }
82:
83: artype=(**ptrptr);
84: switch(artype) {
85: case AR_ANSI: /* No arguments */
86: case AR_RIP:
87: case AR_WIP:
88: case AR_LOCAL:
89: case AR_EXPERT:
90: case AR_SYSOP:
91: case AR_QUIET:
92: case AR_OS2:
93: case AR_DOS:
94: break;
95: default:
96: (*ptrptr)++;
97: break; }
98:
99: n=(**ptrptr);
100: i=(*(short *)*ptrptr);
101: switch(artype) {
102: case AR_LEVEL:
103: if((equal && user->level!=n) || (!equal && user->level<n))
104: result=not;
105: else
106: result=!not;
107: if(!result) {
108: noaccess_str=text[NoAccessLevel];
109: noaccess_val=n; }
110: break;
111: case AR_AGE:
112: age=getage(&cfg,user->birth);
113: if((equal && age!=n) || (!equal && age<n))
114: result=not;
115: else
116: result=!not;
117: if(!result) {
118: noaccess_str=text[NoAccessAge];
119: noaccess_val=n; }
120: break;
121: case AR_BPS:
122: if((equal && cur_rate!=i) || (!equal && cur_rate<i))
123: result=not;
124: else
125: result=!not;
126: (*ptrptr)++;
127: if(!result) {
128: noaccess_str=text[NoAccessBPS];
129: noaccess_val=i; }
130: break;
131: case AR_ANSI:
132: if(!(user->misc&ANSI))
133: result=not;
134: else result=!not;
135: break;
136: case AR_RIP:
137: if(!(user->misc&RIP))
138: result=not;
139: else result=!not;
140: break;
141: case AR_WIP:
142: if(!(user->misc&WIP))
143: result=not;
144: else result=!not;
145: break;
146: case AR_OS2:
147: #ifndef __OS2__
148: result=not;
149: #else
150: result=!not;
151: #endif
152: break;
153: case AR_DOS:
154: #ifdef __FLAT__
155: result=not;
156: #else
157: result=!not;
158: #endif
159: break;
160: case AR_WIN32:
161: #ifndef _WIN32
162: result=not;
163: #else
164: result=!not;
165: #endif
166: break;
167: case AR_UNIX:
168: #ifndef __unix__
169: result=not;
170: #else
171: result=!not;
172: #endif
173: break;
174: case AR_LINUX:
175: #ifndef __linux__
176: result=not;
177: #else
178: result=!not;
179: #endif
180: break;
181: case AR_EXPERT:
182: if(!(user->misc&EXPERT))
183: result=not;
184: else result=!not;
185: break;
186: case AR_SYSOP:
187: if(!SYSOP)
188: result=not;
189: else result=!not;
190: break;
191: case AR_QUIET:
192: if(thisnode.status!=NODE_QUIET)
193: result=not;
194: else result=!not;
195: break;
196: case AR_LOCAL:
197: if(online!=ON_LOCAL)
198: result=not;
199: else result=!not;
200: break;
201: case AR_DAY:
202: now=time(NULL);
203: tm=localtime(&now);
204: if(tm==NULL || (equal && tm->tm_wday!=(int)n)
205: || (!equal && tm->tm_wday<(int)n))
206: result=not;
207: else
208: result=!not;
209: if(!result) {
210: noaccess_str=text[NoAccessDay];
211: noaccess_val=n; }
212: break;
213: case AR_CREDIT:
214: l=(ulong)i*1024UL;
215: if((equal && user->cdt+user->freecdt!=l)
216: || (!equal && user->cdt+user->freecdt<l))
217: result=not;
218: else
219: result=!not;
220: (*ptrptr)++;
221: if(!result) {
222: noaccess_str=text[NoAccessCredit];
223: noaccess_val=l; }
224: break;
225: case AR_NODE:
226: if((equal && cfg.node_num!=n) || (!equal && cfg.node_num<n))
227: result=not;
228: else
229: result=!not;
230: if(!result) {
231: noaccess_str=text[NoAccessNode];
232: noaccess_val=n; }
233: break;
234: case AR_USER:
235: if((equal && user->number!=i) || (!equal && user->number<i))
236: result=not;
237: else
238: result=!not;
239: (*ptrptr)++;
240: if(!result) {
241: noaccess_str=text[NoAccessUser];
242: noaccess_val=i; }
243: break;
244: case AR_GROUP:
245: if((equal
246: && (cursubnum>=cfg.total_subs
247: || cfg.sub[cursubnum]->grp!=i))
248: || (!equal && cursubnum<cfg.total_subs
249: && cfg.sub[cursubnum]->grp<i))
250: result=not;
251: else
252: result=!not;
253: (*ptrptr)++;
254: if(!result) {
255: noaccess_str=text[NoAccessGroup];
256: noaccess_val=i+1; }
257: break;
258: case AR_SUB:
259: if((equal && cursubnum!=i) || (!equal && cursubnum<i))
260: result=not;
261: else
262: result=!not;
263: (*ptrptr)++;
264: if(!result) {
265: noaccess_str=text[NoAccessSub];
266: noaccess_val=i+1; }
267: break;
268: case AR_SUBCODE:
269: if(cursubnum>=cfg.total_subs
270: || strcmp(cfg.sub[cursubnum]->code,(char*)*ptrptr))
271: result=not;
272: else
273: result=!not;
274: while(*(*ptrptr))
275: (*ptrptr)++;
276: if(!result)
277: noaccess_str=text[NoAccessSub];
278: break;
279: case AR_LIB:
280: if((equal
281: && (curdirnum>=cfg.total_dirs
282: || cfg.dir[curdirnum]->lib!=i))
283: || (!equal && curdirnum<cfg.total_dirs
284: && cfg.dir[curdirnum]->lib<i))
285: result=not;
286: else
287: result=!not;
288: (*ptrptr)++;
289: if(!result) {
290: noaccess_str=text[NoAccessLib];
291: noaccess_val=i+1; }
292: break;
293: case AR_DIR:
294: if((equal && curdirnum!=i) || (!equal && curdirnum<i))
295: result=not;
296: else
297: result=!not;
298: (*ptrptr)++;
299: if(!result) {
300: noaccess_str=text[NoAccessDir];
301: noaccess_val=i+1; }
302: break;
303: case AR_DIRCODE:
304: if(curdirnum>=cfg.total_dirs
305: || strcmp(cfg.dir[curdirnum]->code,(char *)*ptrptr))
306: result=not;
307: else
308: result=!not;
309: while(*(*ptrptr))
310: (*ptrptr)++;
311: if(!result)
312: noaccess_str=text[NoAccessSub];
313: break;
314: case AR_EXPIRE:
315: now=time(NULL);
316: if(!user->expire || now+((long)i*24L*60L*60L)>user->expire)
317: result=not;
318: else
319: result=!not;
320: (*ptrptr)++;
321: if(!result) {
322: noaccess_str=text[NoAccessExpire];
323: noaccess_val=i; }
324: break;
325: case AR_RANDOM:
326: n=sbbs_random(i+1);
327: if((equal && n!=i) || (!equal && n<i))
328: result=not;
329: else
330: result=!not;
331: (*ptrptr)++;
332: break;
333: case AR_LASTON:
334: now=time(NULL);
335: if((now-user->laston)/(24L*60L*60L)<(long)i)
336: result=not;
337: else
338: result=!not;
339: (*ptrptr)++;
340: break;
341: case AR_LOGONS:
342: if((equal && user->logons!=i) || (!equal && user->logons<i))
343: result=not;
344: else
345: result=!not;
346: (*ptrptr)++;
347: break;
348: case AR_MAIN_CMDS:
349: if((equal && main_cmds!=i) || (!equal && main_cmds<i))
350: result=not;
351: else
352: result=!not;
353: (*ptrptr)++;
354: break;
355: case AR_FILE_CMDS:
356: if((equal && xfer_cmds!=i) || (!equal && xfer_cmds<i))
357: result=not;
358: else
359: result=!not;
360: (*ptrptr)++;
361: break;
362: case AR_TLEFT:
363: if(timeleft/60<(ulong)n)
364: result=not;
365: else
366: result=!not;
367: if(!result) {
368: noaccess_str=text[NoAccessTimeLeft];
369: noaccess_val=n; }
370: break;
371: case AR_TUSED:
372: if((time(NULL)-logontime)/60<(long)n)
373: result=not;
374: else
375: result=!not;
376: if(!result) {
377: noaccess_str=text[NoAccessTimeUsed];
378: noaccess_val=n; }
379: break;
380: case AR_TIME:
381: now=time(NULL);
382: tm=gmtime(&now);
383: if(tm==NULL || (tm->tm_hour*60)+tm->tm_min<(int)i)
384: result=not;
385: else
386: result=!not;
387: (*ptrptr)++;
388: if(!result) {
389: noaccess_str=text[NoAccessTime];
390: noaccess_val=i; }
391: break;
392: case AR_PCR:
393: if(user->logons>user->posts
394: && (!user->posts || 100/(user->logons/user->posts)<(long)n))
395: result=not;
396: else
397: result=!not;
398: if(!result) {
399: noaccess_str=text[NoAccessPCR];
400: noaccess_val=n; }
401: break;
402: case AR_UDR: /* up/download byte ratio */
403: l=user->dlb;
404: if(!l) l=1;
405: if(user->dlb>user->ulb
406: && (!user->ulb || 100/(l/user->ulb)<n))
407: result=not;
408: else
409: result=!not;
410: if(!result) {
411: noaccess_str=text[NoAccessUDR];
412: noaccess_val=n; }
413: break;
414: case AR_UDFR: /* up/download file ratio */
415: i=user->dls;
416: if(!i) i=1;
417: if(user->dls>user->uls
418: && (!user->uls || 100/(i/user->uls)<n))
419: result=not;
420: else
421: result=!not;
422: if(!result) {
423: noaccess_str=text[NoAccessUDFR];
424: noaccess_val=n; }
425: break;
426: case AR_FLAG1:
427: if((!equal && !(user->flags1&FLAG(n)))
428: || (equal && user->flags1!=FLAG(n)))
429: result=not;
430: else
431: result=!not;
432: if(!result) {
433: noaccess_str=text[NoAccessFlag1];
434: noaccess_val=n; }
435: break;
436: case AR_FLAG2:
437: if((!equal && !(user->flags2&FLAG(n)))
438: || (equal && user->flags2!=FLAG(n)))
439: result=not;
440: else
441: result=!not;
442: if(!result) {
443: noaccess_str=text[NoAccessFlag2];
444: noaccess_val=n; }
445: break;
446: case AR_FLAG3:
447: if((!equal && !(user->flags3&FLAG(n)))
448: || (equal && user->flags3!=FLAG(n)))
449: result=not;
450: else
451: result=!not;
452: if(!result) {
453: noaccess_str=text[NoAccessFlag3];
454: noaccess_val=n; }
455: break;
456: case AR_FLAG4:
457: if((!equal && !(user->flags4&FLAG(n)))
458: || (equal && user->flags4!=FLAG(n)))
459: result=not;
460: else
461: result=!not;
462: if(!result) {
463: noaccess_str=text[NoAccessFlag4];
464: noaccess_val=n; }
465: break;
466: case AR_REST:
467: if((!equal && !(user->rest&FLAG(n)))
468: || (equal && user->rest!=FLAG(n)))
469: result=not;
470: else
471: result=!not;
472: if(!result) {
473: noaccess_str=text[NoAccessRest];
474: noaccess_val=n; }
475: break;
476: case AR_EXEMPT:
477: if((!equal && !(user->exempt&FLAG(n)))
478: || (equal && user->exempt!=FLAG(n)))
479: result=not;
480: else
481: result=!not;
482: if(!result) {
483: noaccess_str=text[NoAccessExempt];
484: noaccess_val=n; }
485: break;
486: case AR_SEX:
487: if(user->sex!=n)
488: result=not;
489: else
490: result=!not;
491: if(!result) {
492: noaccess_str=text[NoAccessSex];
493: noaccess_val=n; }
494: break; } }
495: return(result);
496: }
497:
498: bool sbbs_t::chk_ar(uchar *ar, user_t* user)
499: {
500: uchar *p;
501:
502: if(ar==NULL)
503: return(true);
504: p=ar;
505: return(ar_exp(&p,user));
506: }
507:
508:
509: /****************************************************************************/
510: /* This function fills the usrsub, usrsubs, usrgrps, curgrp, and cursub */
511: /* variables based on the security clearance of the current user (useron) */
512: /****************************************************************************/
513: void sbbs_t::getusrsubs()
514: {
515: uint i,j,k,l;
516:
517: for(j=0,i=0;i<cfg.total_grps;i++) {
518: if(!chk_ar(cfg.grp[i]->ar,&useron))
519: continue;
520: for(k=0,l=0;l<cfg.total_subs;l++) {
521: if(cfg.sub[l]->grp!=i) continue;
522: if(!chk_ar(cfg.sub[l]->ar,&useron))
523: continue;
524: usrsub[j][k++]=l;
525: }
526: usrsubs[j]=k;
527: if(!k) /* No subs accessible in group */
528: continue;
529: usrgrp[j++]=i;
530: }
531: usrgrps=j;
532: if(usrgrps==0)
533: return;
534: while((curgrp>=usrgrps || !usrsubs[curgrp]) && curgrp) curgrp--;
535: while(cursub[curgrp]>=usrsubs[curgrp] && cursub[curgrp]) cursub[curgrp]--;
536: }
537:
538: /****************************************************************************/
539: /* This function fills the usrdir, usrdirs, usrlibs, curlib, and curdir */
540: /* variables based on the security clearance of the current user (useron) */
541: /****************************************************************************/
542: void sbbs_t::getusrdirs()
543: {
544: uint i,j,k,l;
545:
546: if(useron.rest&FLAG('T')) {
547: usrlibs=0;
548: return;
549: }
550: for(j=0,i=0;i<cfg.total_libs;i++) {
551: if(!chk_ar(cfg.lib[i]->ar,&useron))
552: continue;
553: for(k=0,l=0;l<cfg.total_dirs;l++) {
554: if(cfg.dir[l]->lib!=i) continue;
555: if(!chk_ar(cfg.dir[l]->ar,&useron))
556: continue;
557: usrdir[j][k++]=l; }
558: usrdirs[j]=k;
559: if(!k) /* No dirs accessible in lib */
560: continue;
561: usrlib[j++]=i;
562: }
563: usrlibs=j;
564: if(usrlibs==0)
565: return;
566: while((curlib>=usrlibs || !usrdirs[curlib]) && curlib) curlib--;
567: while(curdir[curlib]>=usrdirs[curlib] && curdir[curlib]) curdir[curlib]--;
568: }
569:
570: int sbbs_t::dir_op(uint dirnum)
571: {
572: return(SYSOP || (cfg.dir[dirnum]->op_ar[0] && chk_ar(cfg.dir[dirnum]->op_ar,&useron)));
573: }
574:
575:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.