![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pr_prot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu|
Return to pr_prot.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu |
1.1 root 1: # include <ingres.h>
2: # include <tree.h>
3: # include <aux.h>
4: # include <catalog.h>
5: # include <symbol.h>
6: # include <sccs.h>
7:
8: SCCSID(@(#)pr_prot.c 7.1 2/5/81)
9:
10: /*
11: ** PR_PROT.C -- Print out a protection query
12: **
13: ** Trace Flags:
14: ** 51
15: */
16:
17:
18:
19:
20:
21:
22: extern QTREE *gettree(); /* gets a tree from "tree" catalog [readtree.c] */
23:
24: char *Days [] =
25: {
26: "sunday",
27: "monday",
28: "tuesday",
29: "wednesday",
30: "thursday",
31: "friday",
32: "saturday",
33: };
34:
35: struct rngtab
36: {
37: char relid [MAXNAME];
38: char rowner [2];
39: char rused;
40: };
41:
42:
43:
44:
45: /*
46: ** PR_PROT -- print out protection info on a relation
47: **
48: ** Prints out a "define permit" statement for
49: ** each permission on a relation.
50: ** First calls pr_spec_permit() to print permissions
51: ** indicated in the relation.relstat bits. Lower level pr_??
52: ** routines look for these bits, so in the calls to pr_permit
53: ** for tuples actually gotten from the "protect" catalog,
54: ** pr_prot sets the relstat bits, thereby suppressing their special
55: ** meaning (they are inverse bits: 0 means on).
56: **
57: ** Parameters:
58: ** relid -- non-unique relation name used by user in DBU call
59: ** r -- ptr to relation tuple
60: **
61: ** Returns:
62: ** 0 -- some permissions on rel
63: ** 1 -- no permissions on rel
64: **
65: ** Side Effects:
66: ** reads trees from protection catalog
67: **
68: ** Trace Flags:
69: ** 39, 0
70: */
71:
72: pr_prot(relid, r)
73: char *relid;
74: register struct relation *r;
75: {
76: extern DESC Prodes;
77: TID hitid, lotid;
78: struct protect key, tuple;
79: register int i;
80: int flag; /* indicates whether a special case occurred */
81:
82: # ifdef xZTR1
83: if (tTf(51, 0))
84: printf("pr_prot: relation \"%s\" owner \"%s\"relstat 0%o\n",
85: r->relid, r->relowner, r->relstat);
86: # endif
87:
88: flag = 0;
89: if (r->relstat & S_PROTUPS || !(r->relstat & S_PROTALL)
90: || !(r->relstat & S_PROTRET))
91: printf("Permissions on %s are:\n\n", relid);
92: /* print out special permissions, if any */
93: flag += pr_spec_permit(r, S_PROTALL);
94: flag += pr_spec_permit(r, S_PROTRET);
95:
96: if (!(r->relstat & S_PROTUPS))
97: if (flag)
98: return (0);
99: else
100: return (1);
101: opencatalog("protect", 0);
102:
103: /* get protect catalog tuples for "r", "owner" */
104: clearkeys(&Prodes);
105: setkey(&Prodes, &key, r->relid, PRORELID);
106: setkey(&Prodes, &key, r->relowner, PRORELOWN);
107: if (i = find(&Prodes, EXACTKEY, &lotid, &hitid, &key))
108: syserr("pr_prot: find %d", i);
109: /* ready for pr_user call to getuser() */
110: getuser(-1);
111: for ( ; ; )
112: {
113: if (i = get(&Prodes, &lotid, &hitid, &tuple, TRUE))
114: break;
115: /* print out protection info */
116: if (kcompare(&Prodes, &tuple, &key) == 0)
117: /* permission from real protect tuple, concoct
118: * neutral relstat
119: */
120: pr_permit(&tuple, r->relstat | S_PROTALL | S_PROTRET);
121: }
122: if (i != 1)
123: syserr("pr_prot: get %d", i);
124:
125: /* close user file opened by pr_user call to getuser */
126: getuser(0);
127: }
128: /*
129: ** PR_SPEC_PERMIT -- Print out special permissions
130: ** Prints out permissios indicated by the relation.relstat field bits.
131: ** Concocts a protection tuple for the permission and assigns a
132: ** propermid-like number to it for printing. Passes to pr_permit()
133: ** the concocted tuple, together with a relstat where the appropriate
134: ** bit is 0, so that the special printing at the lower level pr_???
135: ** routines takes place.
136: **
137: ** Parameters:
138: ** r -- relation relation tuple for the permitted relation
139: ** relst_bit -- if this bit is 0 inthe relstat, prints the query
140: ** {S_PROTALL, S_PROTRET}
141: **
142: ** Returns:
143: ** 1 -- if prints
144: ** 0 -- otherwise
145: */
146:
147:
148: pr_spec_permit(r, relst_bit)
149: register struct relation *r;
150: int relst_bit;
151: {
152: register struct protect *p;
153: struct protect prot;
154:
155: if (r->relstat & relst_bit)
156: return (0);
157: p = &prot;
158: clrmem(p, sizeof *p);
159: p->protree = -1;
160: if (relst_bit == S_PROTALL)
161: p->propermid = 0;
162: else if (relst_bit == S_PROTRET)
163: p->propermid = 1;
164: else
165: syserr("pr_spec_permit(relst_bit == 0%o)", relst_bit);
166:
167: bmove(r->relid, p->prorelid, MAXNAME);
168: bmove(" ", p->prouser, 2);
169: pmove("", p->proterm, sizeof p->proterm, ' ');
170: pr_permit(p, (r->relstat | S_PROTRET | S_PROTALL) & ~relst_bit);
171: return (1);
172: }
173: /*
174: ** PR_PERMIT -- print out a DEFINE PERMIT query for a protection tuple
175: **
176: ** Parameters:
177: ** p -- ptr to protection tuple
178: ** relstat -- relstat from relation
179: **
180: ** Returns:
181: ** none
182: **
183: ** Side Effects:
184: ** reads in a tree from the "tree" catalog
185: ** prints out a query
186: */
187:
188:
189: pr_permit(p, relstat)
190: register struct protect *p;
191: int relstat;
192: {
193: register QTREE *t;
194: extern DESC Prodes;
195: DESC pdesc;
196:
197: /*
198: * if there is a qualification then
199: * clear range table, then read in protect tree,
200: * the print out range statements
201: * else create single entry range table.
202: */
203: clrrange();
204: if (p->protree >= 0)
205: {
206: t = gettree(p->prorelid, p->prorelown, mdPROT, p->protree, TRUE);
207: }
208: else
209: {
210: t = 0;
211: bmove(p->prorelid, pdesc.reldum.relid, MAXNAME);
212: bmove(p->prorelown, pdesc.reldum.relowner, 2);
213: declare(0, &pdesc);
214: p->proresvar = 0;
215: }
216: printf("Permission %d -\n\n", p->propermid);
217: pr_range();
218:
219: # ifdef xZTR1
220: if (tTf(51, 1))
221: {
222: printf("pr_permit: prot=");
223: printup(&Prodes, p);
224: printf(", Qt.qt_resvar=%d\n", Qt.qt_resvar);
225: }
226: # endif
227:
228: /* print out query */
229: printf("define permit ");
230: pr_ops(p->proopset, relstat);
231: printf("on ");
232: pr_rv(Qt.qt_resvar = p->proresvar);
233: putchar(' ');
234: pr_doms(p->prodomset, relstat);
235: printf("\n\t");
236: pr_user(p->prouser);
237: pr_term(p->proterm);
238: if ((relstat & S_PROTRET) && (relstat & S_PROTALL))
239: {
240: /* not special case */
241: pr_time(p->protodbgn, p->protodend);
242: pr_day(p->prodowbgn, p->prodowend);
243: }
244: if (t && t->right->sym.type != QLEND)
245: {
246: printf("\nwhere ");
247: pr_qual(t->right);
248: }
249: printf("\n\n\n");
250:
251: /* clear up the old range table */
252: clrrange();
253: }
254: /*
255: ** PR_OPS -- Prints the the operation list defined by a protection opset
256: **
257: ** Eliminates the appropriate bits from a copy of the opset while printing
258: ** out the appropriate operation list.
259: **
260: ** Parameters:
261: ** opset -- protection.opset for the relation
262: ** relstat
263: **
264: ** Returns:
265: ** none
266: **
267: ** Side Effects:
268: ** printing of permitted op list
269: */
270:
271: pr_ops(opset, relstat)
272: int opset;
273: int relstat;
274: {
275: register int op, j;
276:
277: # ifdef xZTR1
278: if (tTf(51, 2))
279: printf("pr_ops(0%o)\n", opset);
280: # endif
281:
282: if (!(relstat & S_PROTALL) || opset == -1)
283: {
284: printf("all ");
285: return;
286: }
287: if (!(relstat & S_PROTRET))
288: {
289: printf("retrieve ");
290: return;
291: }
292:
293: op = (opset & ~PRO_AGGR & ~PRO_TEST) & 077;
294: for ( ; ; )
295: {
296: if (op & (j = PRO_RETR))
297: printf("retrieve");
298: else if (op & (j = PRO_REPL))
299: printf("replace");
300: else if (op & (j = PRO_DEL))
301: printf("delete");
302: else if (op & (j = PRO_APP))
303: printf("append");
304: op ^= j;
305: if (op)
306: printf(", ");
307: else
308: break;
309: }
310: putchar(' ');
311: }
312: /*
313: ** PR_DOMS -- Print domains in permit target list
314: **
315: ** Parameters:
316: ** doms -- an 8 byte integer array; a bit map of the domains
317: ** if all 8 integers are -1, then "all" is printed fo
318: ** for the target list
319: ** relstat
320: **
321: ** Returns:
322: ** none
323: **
324: ** Side Effects:
325: ** prints out target list
326: */
327:
328: pr_doms(doms, relstat)
329: short doms[8];
330: int relstat;
331: {
332: register short *d;
333: register int flag, shift;
334: int word;
335: char *rel;
336:
337: word = shift = 0;
338: d = doms;
339: rel = Qt.qt_rangev[Qt.qt_resvar].rngvdesc->reldum.relid;
340:
341: # ifdef xZTR1
342: if (tTf(51, 3))
343: {
344: printf("pr_doms: rel=\"%s\" ", rel);
345: for (word = 0; word < 8; )
346: printf("0%o ", d [word++]);
347: word = 0;
348: putchar('\n');
349: }
350: # endif
351: if (!(relstat & S_PROTALL) || !(relstat & S_PROTRET))
352: return;
353: flag = 1;
354: for (word = 0; word < 8; word++)
355: if (*d++ != -1)
356: {
357: flag = 0;
358: break;
359: }
360:
361: if (!flag)
362: {
363: putchar('(');
364: for (d = doms, word = 0; word < 8; word++, d++)
365: {
366: for (shift = 0; shift < 16; shift++, *d >>= 1)
367: {
368: if (*d & 01)
369: {
370: if (flag++)
371: printf(", ");
372: pr_attname(rel, word * 16 + shift);
373: }
374: }
375: }
376: putchar(')');
377: }
378: }
379: /*
380: ** PR_USER -- prints out permitted user's name
381: **
382: ** Parameters:
383: ** user -- 2 char array, user's usercode as in
384: ** users file
385: **
386: ** Returns:
387: ** none
388: **
389: ** Side Effects:
390: ** prints users name or "all" if user was " "
391: */
392:
393: pr_user(user)
394: char user[2];
395: {
396: register i;
397: char buf[MAXLINE];
398: register char *c, *u;
399:
400: # ifdef xZTR1
401: if (tTf(51, 4))
402: printf("pr_user(\"%c%c\")\n", user[0], user[1]);
403: # endif
404:
405: c = buf;
406: u = user;
407: printf("to ");
408: if (bequal(u, " ", 2))
409: printf("all ");
410: else
411: {
412: if (getuser(u, c))
413: {
414: printf("%c%c ", u[0], u[1]);
415: return;
416: }
417: while (*c != ':' && *c != '\n')
418: putchar(*c++);
419: putchar(' ');
420: }
421: }
422: /*
423: ** PR_TIME -- Prints out clock time range access is allowed
424: **
425: ** Parameters:
426: ** bgn, end -- begin end times in seconds (if all day, returns)
427: **
428: ** Returns:
429: ** none
430: **
431: ** Side Effects:
432: ** prints out time
433: */
434:
435: pr_time(bgn, end)
436: int bgn, end;
437: {
438: char time [3];
439: register char *t;
440: register int b, e;
441:
442: t = time;
443: b = bgn;
444: e = end;
445: # ifdef xZTR1
446: if (tTf(51, 5))
447: printf("pr_time(bgn=%d, end=%d)\n", b, e);
448: # endif
449: if (b == 0 && e == 24 * 60)
450: return;
451: printf("from %d:", b / 60);
452: itoa(b % 60, t);
453: if (!t [1])
454: putchar('0');
455: printf("%s to %d:", t, e / 60);
456: itoa(e % 60, t);
457: if (!t [1])
458: putchar('0');
459: printf("%s ", t);
460: }
461: /*
462: ** PR_DAY -- Prints day range permitted
463: **
464: ** Parameters:
465: ** bgn, end -- bgn end days [0..6] (if all week returns)
466: **
467: ** Returns:
468: ** none
469: **
470: ** Side Effects:
471: ** prints days or nothing
472: */
473:
474: pr_day(bgn, end)
475: int bgn, end;
476: {
477: # ifdef xZTR1
478: if (tTf(51, 6))
479: printf("pr_day(bgn=%d, end=%d)\n", bgn, end);
480: # endif
481: if (bgn == 0 && end >= 6)
482: return;
483: printf("on %s to %s ", Days [bgn], Days [end]);
484: }
485: /*
486: ** PR_TERM -- Print terminal from which access permitted
487: **
488: ** Parameters:
489: ** term -- 1 char terminal id as in /etc/tty* (if ' ' the returns)
490: **
491: ** Returns:
492: ** none
493: **
494: ** Side Effects:
495: ** prints terminal or nothing
496: */
497:
498: pr_term(term)
499: char term[8];
500: {
501: # ifdef xZTR1
502: if (tTf(51, 7))
503: printf("pr_term(term='%.8s')\n", term);
504: # endif
505:
506: if (term[0] != ' ')
507: printf("at %8.8s ", term);
508: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.