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: }
|
Last modified: 1995-06-20
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 3542 |
|