# 2.11BSD#431 - /usr/ingres/source/dbu/pr_prot.c

##### Functions

    pr_day            X
    pr_doms           X
    pr_ops            X
    pr_permit         X
    pr_prot           X
    pr_spec_permit    X
    pr_term           X
    pr_time           X
    pr_user           X

##### Variables

    Days              X
    Rangev            X

##### Macros

    QTREE             X

##### struct's

    rngtab            X

       1: #
       2:
       3: /*
       4: **  PR_PROT.C -- Print out a protection query
       5: **
       6: **	Defines:
       7: **		pr_prot() -- given a relation owner pair, prints protection
       8: **			queries issued on the relation
       9: **
      10: **	Required By:
      11: **		disp() -- [display.c]
      12: **
      13: **	Conditional Compilation:
      14: **		xZTR1 -- for trace flags
      15: **
      16: **	Trace Flags:
      17: **		11
      18: **
      19: **	History:
      20: **		11/15/78 -- (marc) written
      21: */
      22:
      23:
      24:
      25:
      26: # include   "../ingres.h"
      27: # include   "../tree.h"
      28: # include   "../aux.h"
      29: # include   "../unix.h"
      30: # include   "../catalog.h"
      31: # include   "../symbol.h"
      32:
      33:
      34: # define    QTREE       struct querytree
      35:
      36:
      37: QTREE   *gettree(); /* gets a tree from "tree" catalog [readtree.c] */
      38:
      39: char    *Days [] =
      40: {
      41:     "sunday",
      42:     "monday",
      43:     "tuesday",
      44:     "wednesday",
      45:     "thursday",
      46:     "friday",
      47:     "saturday",
      48: };
      49:
      50: # define    QTREE       struct querytree
      51:
      52: struct rngtab
      53: {
      54:     char    relid [MAXNAME];
      55:     char    rowner [2];
      56:     char    rused;
      57: };
      58:
      59: struct rngtab   Rangev[MAXVAR + 1];
      60:
      61:
      62:
      63: /*
      64: **  PR_PROT -- print out protection info on a relation
      65: **
      66: **	Prints out a "define permit" statement for
      67: **	each permission on a relation.
      68: **	First calls pr_spec_permit() to print permissions
      69: **	indicated in the relation.relstat bits. Lower level pr_??
      70: **	routines look for these bits, so in the calls to pr_permit
      71: **	for tuples actually gotten from the "protect" catalog,
      72: **	pr_prot sets the relstat bits, thereby suppressing their special
      73: **	meaning (they are inverse bits: 0 means on).
      74: **
      75: **	Parameters:
      76: **		relid -- non-unique relation name used by user in DBU call
      77: **		rel -- relation tuple
      78: **
      79: **	Returns:
      80: **		0 -- some permissions on rel
      81: **		1 -- no permissions on rel
      82: **
      83: **	Side Effects:
      84: **		reads trees from protection catalog
      85: **
      86: **	Requires:
      87: **		pr_permit() -- to generate query from protection tuple
      88: **		pr_spec_permit() -- to print out relstat generated permissions
      89: **
      90: **	Called By:
      91: **		disp() [display.c]
      92: **
      93: **	Trace Flags:
      94: **		11, 0
      95: **
      96: **	Syserrs:
      97: **		on bad returns from find(), get(), and openr()
      98: **
      99: **	History:
     100: **		11/15/78 -- (marc) written
     101: **		12/19/78 -- (marc) modified to take into account S_PROT[12]
     102: **		1/9/79 -- (marc)    "		"	    "	S_PROT[ALL,RET]
     103: */
     104:
     105: pr_prot(relid, rel)
     106: char            *relid;
     107: struct relation     *rel;
     108: {
     109:     extern struct descriptor    Prodes;
     110:     struct tup_id           hitid, lotid;
     111:     struct protect          key, tuple;
     112:     register            i;
     113:     int             flag;   /* indicates wether a special
     114: 						 * case occurred
     115: 						 */
     116:     register struct relation    *r;
     117:
     118: #	ifdef xZTR1
     119:     if (tTf(11, 0))
     120:         printf("pr_prot: relation \"%s\" owner \"%s\"relstat 0%o\n",
     121:         rel->relid, rel->relowner, rel->relstat);
     122: #	endif
     123:
     124:     r = rel;
     125:     flag = 0;
     126:     if (r->relstat & S_PROTUPS || !(r->relstat & S_PROTALL)
     127:        || !(r->relstat & S_PROTRET))
     128:         printf("Permissions on %s are:\n\n", relid);
     129:     /* print out special permissions, if any */
     130:     flag += pr_spec_permit(r, S_PROTALL);
     131:     flag += pr_spec_permit(r, S_PROTRET);
     132:
     133:     if (!(r->relstat & S_PROTUPS))
     134:         if (flag)
     135:             return (0);
     136:         else
     137:             return (1);
     138:     opencatalog("protect", 0);
     139:
     140:     /* get protect catalog tuples for "r", "owner" */
     141:     clearkeys(&Prodes);
     142:     setkey(&Prodes, &key, r->relid, PRORELID);
     143:     setkey(&Prodes, &key, r->relowner, PRORELOWN);
     144:     if (i = find(&Prodes, EXACTKEY, &lotid, &hitid, &key))
     145:         syserr("pr_prot: find %d", i);
     146:     /* ready for pr_user call to getuser() */
     147:     getuser(-1);
     148:     for ( ; ; )
     149:     {
     150:         if (i = get(&Prodes, &lotid, &hitid, &tuple, TRUE))
     151:             break;
     152:         /* print out protection info */
     153:         if (kcompare(&Prodes, &tuple, &key) == 0)
     154:             /* permission from real protect tuple, concoct
     155: 			 * neutral relstat
     156: 			 */
     157:             pr_permit(&tuple, r->relstat | S_PROTALL | S_PROTRET);
     158:     }
     159:     if (i != 1)
     160:         syserr("pr_prot: get %d", i);
     161:
     162:     /* close user file opened by pr_user call to getuser */
     163:     getuser(0);
     164: }
     165:
     166: /*
     167: **  PR_SPEC_PERMIT -- Print out special permissions
     168: **	Prints out permissios indicated by the relation.relstat field bits.
     169: **	Concocts a protection tuple for the permission and assigns a
     170: **	propermid-like number to it for printing. Passes to pr_permit()
     171: **	the concocted tuple, together with a relstat where the appropriate
     172: **	bit is 0, so that the special printing at the lower level pr_???
     173: **	routines takes place.
     174: **
     175: **	Parameters:
     176: **		rel -- relation relation tuple for the permitted relation
     177: **		relst_bit -- if this bit is 0 inthe relstat, prints the query
     178: **				{S_PROTALL, S_PROTRET}
     179: **
     180: **	Returns:
     181: **		1 -- if prints
     182: **		0 -- otherwise
     183: **
     184: **	Requires:
     185: **		pr_permit()
     186: **
     187: **	Called By:
     188: **		pr_prot()
     189: **
     190: **	Syserrs:
     191: **		relst_bit ! in {S_PROTALL, S_PROTRET}
     192: **
     193: **	History:
     194: **		1/9/79 -- (marc) written to handle S_PROTALL and S_PROTRET
     195: */
     196:
     197:
     198: pr_spec_permit(rel, relst_bit)
     199: struct relation     *rel;
     200: int         relst_bit;
     201: {
     202:     register struct relation    *r;
     203:     register struct protect     *p;
     204:     struct protect          prot;
     205:
     206:     r = rel;
     207:     if (r->relstat & relst_bit)
     208:         return (0);
     209:     p = &prot;
     210:     p->protree = -1;
     211:     if (relst_bit == S_PROTALL)
     212:         p->propermid = 0;
     213:     else if (relst_bit == S_PROTRET)
     214:         p->propermid = 1;
     215:     else
     216:         syserr("pr_spec_permit(relst_bit == 0%o)", relst_bit);
     217:
     218:     bmove(r->relid, p->prorelid, MAXNAME);
     219:     bmove("  ", p->prouser, 2);
     220:     bmove(" ", &p->proterm, 1);
     221:     pr_permit(p, (r->relstat | S_PROTRET | S_PROTALL) & ~relst_bit);
     222:     return (1);
     223: }
     224:
     225:
     226: /*
     227: **  PR_PERMIT -- print out a DEFINE PERMIT query for a protection tuple
     228: **
     229: **	Parameters:
     230: **		prot -- protection tuple
     231: **		relstat -- relstat from relation
     232: **
     233: **	Returns:
     234: **		none
     235: **
     236: **	Side Effects:
     237: **		reads in a tree from the "tree" catalog
     238: **		prints out a query
     239: **
     240: **	Requires:
     241: **		clrrange(), pr_range() -- to initialize and print range table
     242: **		gettree() -- to read in "tree" tree and fill range table
     243: **		pr_ops(),
     244: **		pr_doms(),
     245: **		pr_user(),
     246: **		pr_term(),
     247: **		pr_time(),
     248: **		pr_day() -- to print out parts of query
     249: **		pr_qual() -- [pr_tree.c] to print out qualification
     250: **
     251: **	Called By:
     252: **		pr_prot()
     253: **		pr_spec_permit()
     254: **
     255: **	Trace Flags:
     256: **		11, 1
     257: **
     258: **	History:
     259: **		11/15/78 -- (marc) written
     260: **		12/19/78 -- (marc) changed to deal with relstat
     261: **		1/9/79 -- (marc)    "		"	  "
     262: */
     263:
     264:
     265: pr_permit(prot, relstat)
     266: struct protect  *prot;
     267: int     relstat;
     268: {
     269:     register struct protect     *p;
     270:     register QTREE          *t;
     271:     extern int          Resultvar;
     272:     extern struct descriptor    Prodes;
     273:
     274:     p = prot;
     275:     /*
     276: 	 * if there is a qualification then
     277: 	 * clear range table, then read in protect tree,
     278: 	 * the print out range statements
     279: 	 * else create single entry range table.
     280: 	 */
     281:     clrrange();
     282:     if (p->protree >= 0)
     283:         t = gettree(p->prorelid, p->prorelown, mdPROT, p->protree);
     284:     else
     285:     {
     286:         t = 0;
     287:         declare(0, p->prorelid, p->prorelown);
     288:         p->proresvar = 0;
     289:     }
     290:     printf("Permission %d -\n\n", p->propermid);
     291:     pr_range();
     292:
     293: #	ifdef xZTR1
     294:     if (tTf(11, 1))
     295:     {
     296:         printf("pr_permit: prot=");
     297:         printup(&Prodes, p);
     298:         printf(", Resultvar=%d\n", Resultvar);
     299:     }
     300: #	endif
     301:
     302:     /* print out query */
     303:     printf("define permit ");
     304:     pr_ops(p->proopset, relstat);
     305:     printf("on ");
     306:     pr_rv(Resultvar = p->proresvar);
     307:     putchar(' ');
     308:     pr_doms(p->prodomset, relstat);
     309:     printf("\n\t");
     310:     pr_user(p->prouser);
     311:     pr_term(p->proterm);
     312:     if ((relstat & S_PROTRET) && (relstat & S_PROTALL))
     313:     {
     314:         /* not special case */
     315:         pr_time(p->protodbgn, p->protodend);
     316:         pr_day(p->prodowbgn, p->prodowend);
     317:     }
     318:     if (t && t->right != QLEND)
     319:     {
     320:         printf("\nwhere ");
     321:         pr_qual(t->right);
     322:     }
     323:     printf("\n\n\n");
     324: }
     325:
     326: /*
     327: **  PR_OPS -- Prints the the operation list defined by a protection opset
     328: **
     329: **	Eliminates the appropriate bits from a copy of the opset while printing
     330: **	out the appropriate operation list.
     331: **
     332: **	Parameters:
     333: **		opset -- protection.opset for the relation
     334: **		relstat
     335: **
     336: **	Returns:
     337: **		none
     338: **
     339: **	Side Effects:
     340: **		printing of permitted op list
     341: **
     342: **	Called By:
     343: **		pr_permit()
     344: **
     345: **	Trace Flags:
     346: **		11, 2
     347: **
     348: **
     349: **	History:
     350: **		11/15/78 -- (marc) written
     351: **		12/19/78 -- (marc) relstat added
     352: **		1/9/79 -- (marc) S_PROTALL and S_PROTRET handled
     353: */
     354:
     355: pr_ops(opset, relstat)
     356: int     opset;
     357: int     relstat;
     358: {
     359:     register    op, j;
     360:
     361: #	ifdef xZTR1
     362:     if (tTf(11, 2))
     363:         printf("pr_ops(0%o)\n", opset);
     364: #	endif
     365:
     366:     if (!(relstat & S_PROTALL) || opset == -1)
     367:     {
     368:         printf("all ");
     369:         return;
     370:     }
     371:     if (!(relstat & S_PROTRET))
     372:     {
     373:         printf("retrieve ");
     374:         return;
     375:     }
     376:
     377:     op = (opset & ~PRO_AGGR & ~PRO_TEST) & 077;
     378:     for ( ; ; )
     379:     {
     380:         if (op & (j = PRO_RETR))
     381:             printf("retrieve");
     382:         else if (op & (j = PRO_REPL))
     383:             printf("replace");
     384:         else if (op & (j = PRO_DEL))
     385:             printf("delete");
     386:         else if (op & (j = PRO_APP))
     387:             printf("append");
     388:         op ^= j;
     389:         if (op)
     390:             printf(", ");
     391:         else
     392:             break;
     393:     }
     394:     putchar(' ');
     395: }
     396:
     397: /*
     398: **  PR_DOMS -- Print domains in permit target list
     399: **
     400: **	Parameters:
     401: **		doms -- an 8 byte integer array; a bit map of the domains
     402: **			if all 8 integers are -1, then "all" is printed fo
     403: **			for the target list
     404: **		relstat
     405: **
     406: **	Returns:
     407: **		none
     408: **
     409: **	Side Effects:
     410: **		prints out target list
     411: **
     412: **	Requires:
     413: **		pr_attname() -- to print out names given relation
     414: **				and domain number
     415: **
     416: **	Called By:
     417: **		pr_permit()
     418: **
     419: **	Trace Flags:
     420: **		11, 3
     421: **
     422: **	History:
     423: **		11/15/78 -- (marc) written
     424: **		1/9/79 -- (marc) modified so will assume all domains if
     425: **			special permission
     426: **		5/22/79 -- (marc) changed so bit of first word is unused
     427: */
     428:
     429: pr_doms(doms, relstat)
     430: int doms [8];
     431: int relstat;
     432: {
     433:     register int        *d;
     434:     register int        flag, shift;
     435:     int         word;
     436:     char            *rel;
     437:     extern int      Resultvar;
     438:
     439:     word = shift = 0;
     440:     d = doms;
     441:     rel = Rangev [Resultvar].relid;
     442:
     443: #	ifdef xZTR1
     444:     if (tTf(11, 3))
     445:     {
     446:         printf("pr_doms: rel=\"%s\" ", rel);
     447:         for (word = 0; word < 8; )
     448:             printf("0%o ", d [word++]);
     449:         word = 0;
     450:         putchar('\n');
     451:     }
     452: #	endif
     453:     if (!(relstat & S_PROTALL) || !(relstat & S_PROTRET))
     454:         return;
     455:     flag = 1;
     456:     for (word = 0; word < 8; word++)
     457:         if (*d++ != -1)
     458:         {
     459:             flag = 0;
     460:             break;
     461:         }
     462:
     463:     if (!flag)
     464:     {
     465:         putchar('(');
     466:         for (d = doms, word = 0; word < 8; word++, d++)
     467:         {
     468:             for (shift = 0; shift < 16; shift++, *d >>= 1)
     469:             {
     470:                 if (*d & 01)
     471:                 {
     472:                     if (flag++)
     473:                         printf(", ");
     474:                     pr_attname(rel, word * 16 + shift);
     475:                 }
     476:             }
     477:         }
     478:         putchar(')');
     479:     }
     480: }
     481:
     482: /*
     483: **  PR_USER -- prints out permitted user's name
     484: **
     485: **	Parameters:
     486: **		user -- 2 char array, user's usercode as in
     487: **			users file
     488: **
     489: **	Returns:
     490: **		none
     491: **
     492: **	Side Effects:
     493: **		prints users name or "all" if user was "  "
     494: **
     495: **	Requires:
     496: **		getuser(UTIL) -- to get user login name.
     497: **
     498: **	Called By:
     499: **		pr_permit()
     500: **
     501: **	Trace Flags:
     502: **		11, 4
     503: **
     504: **	History:
     505: **		11/15/78 -- (marc) written
     506: */
     507:
     508: pr_user(user)
     509: char        user [2];
     510: {
     511:     register        i;
     512:     char            buf [512];
     513:     register char       *c, *u;
     514:
     515: #	ifdef xZTR1
     516:     if (tTf(11, 4))
     517:         printf("pr_user(\"%c%c\")\n", user [0], user [1]);
     518: #	endif
     519:
     520:     c = buf;
     521:     u = user;
     522:     printf("to ");
     523:     if (bequal(u, "  ", 2))
     524:         printf("all ");
     525:     else
     526:     {
     527:         if (getuser(u, c))
     528:         {
     529:             printf("%c%c ", u[0], u[1]);
     530:             return;
     531:         }
     532:         while (*c != ':' && *c != '\n')
     533:             putchar(*c++);
     534:         putchar(' ');
     535:     }
     536: }
     537:
     538: /*
     539: **  PR_TIME -- Prints out clock time range access is allowed
     540: **
     541: **	Parameters:
     542: **		bgn, end -- begin end times in seconds (if all day, returns)
     543: **
     544: **	Returns:
     545: **		none
     546: **
     547: **	Side Effects:
     548: **		prints out time
     549: **
     550: **	Called By:
     551: **		pr_permit()
     552: **
     553: **	Trace Flags:
     554: **		11, 5
     555: **
     556: **	History:
     557: **		11/15/78 -- (marc) written
     558: */
     559:
     560: pr_time(bgn, end)
     561: int     bgn, end;
     562: {
     563:     char        time [3];
     564:     register char   *t;
     565:     register int    b, e;
     566:
     567:     t = time;
     568:     b = bgn;
     569:     e = end;
     570: #	ifdef xZTR1
     571:     if (tTf(11, 5))
     572:         printf("pr_time(bgn=%d, end=%d)\n", b, e);
     573: #	endif
     574:     if (b == 0 && e == 24 * 60)
     575:         return;
     576:     printf("from %d:", b / 60);
     577:     itoa(b % 60, t);
     578:     if (!t [1])
     579:         putchar('0');
     580:     printf("%s to %d:", t, e / 60);
     581:     itoa(e % 60, t);
     582:     if (!t [1])
     583:         putchar('0');
     584:     printf("%s ", t);
     585: }
     586:
     587: /*
     588: **  PR_DAY -- Prints day range permitted
     589: **
     590: **	Parameters:
     591: **		bgn, end -- bgn end days [0..6] (if all week returns)
     592: **
     593: **	Returns:
     594: **		none
     595: **
     596: **	Side Effects:
     597: **		prints days or nothing
     598: **
     599: **	Requires:
     600: **		Days [0..6] -- string array of day names
     601: **
     602: **	Called By:
     603: **		pr_permit()
     604: **
     605: **	Trace Flags:
     606: **		11, 6
     607: **
     608: **	History:
     609: **		11/15/78 -- (marc) written
     610: */
     611:
     612: pr_day(bgn, end)
     613: int     bgn, end;
     614: {
     615: #	ifdef xZTR1
     616:     if (tTf(11, 6))
     617:         printf("pr_day(bgn=%d, end=%d)\n", bgn, end);
     618: #	endif
     619:     if (bgn == 0 && end >= 6)
     620:         return;
     621:     printf("on %s to %s ", Days [bgn], Days [end]);
     622: }
     623:
     624: /*
     625: **  PR_TERM -- Print terminal from which access permitted
     626: **
     627: **	Parameters:
     628: **		term -- 1 char terminal id as in /etc/tty* (if ' ' the returns)
     629: **
     630: **	Returns:
     631: **		none
     632: **
     633: **	Side Effects:
     634: **		prints terminal or nothing
     635: **
     636: **	Called By:
     637: **		pr_permit()
     638: **
     639: **	Trace Flags:
     640: **		11, 7
     641: **
     642: **	History:
     643: **		11/15/78 -- (marc) written
     644: */
     645:
     646: pr_term(term)
     647: # ifdef xV7_UNIX
     648: char        *term;
     649: # endif
     650: # ifndef xV7_UNIX
     651: char        term;
     652: # endif
     653: {
     654: #	ifdef xZTR1
     655:     if (tTf(11, 7))
     656: # ifdef xV7_UNIX
     657:         printf("pr_term(term='%2s')\n", term);
     658: # endif
     659: # ifndef xV7_UNIX
     660:         printf("pr_term(term='%c')\n", term);
     661: # endif
     662: #	endif
     663:
     664: # ifndef xV7_UNIX
     665:     if (term != ' ')
     666:         printf("at tty%c ", term);
     667: # endif
     668: # ifdef xV7_UNIX
     669:     if (*term != ' ')
     670:         printf("at tty%2s ", term);
     671: # endif
     672: }

#### Defined functions

pr_day defined in line 612; used 1 times

- in line 316

pr_doms defined in line 429; used 1 times

- in line 308

pr_ops defined in line 355; used 1 times

- in line 304

pr_permit defined in line 265; used 2 times

- in line 157, 221

pr_prot defined in line 105; used 1 times

- in /usr/ingres/source/dbu/display.c line 184

pr_spec_permit defined in line 198; used 2 times

- in line 130-131(2)

pr_term defined in line 646; used 1 times

- in line 311

pr_time defined in line 560; used 1 times

- in line 315

pr_user defined in line 508; used 1 times

- in line 310

#### Defined variables

Days defined in line 39; used 2 times

- in line 621(2)

Rangev defined in line 59; used 10 times

- in line 441
- in /usr/ingres/source/dbu/pr_tree.c line 498, 578-583(2), 595, 604-606(2), 626
- in /usr/ingres/source/dbu/readtree.c line 422, 444

#### Defined struct's

rngtab defined in line 52; used 2 times

- in line 59(2)

#### Defined macros

QTREE defined in line 50; used 2 times

- in line 37, 270

Last modified: 1995-06-20 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1315 |