Return to chk_ar.cpp CVS log

Up to [Synchronet] / sbbs / sbbs3

Annotation of sbbs/sbbs3/chk_ar.cpp, revision 1.1

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.