home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 September / PCO_0998.ISO / filesbbs / dos / sbbs_src.exe / SBBS / CHK_AR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-24  |  11.4 KB  |  510 lines
  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.  
  510.