#

/*
**  PR_PROT.C -- Print out a protection query
**
**	Defines:
**		pr_prot() -- given a relation owner pair, prints protection
**			queries issued on the relation
**
**	Required By:
**		disp() -- [display.c]
**
**	Conditional Compilation:
**		xZTR1 -- for trace flags
**
**	Trace Flags:
**		11
**
**	History:
**		11/15/78 -- (marc) written
*/




# include	"../ingres.h"
# include	"../tree.h"
# include	"../aux.h"
# include	"../unix.h"
# include	"../catalog.h"
# include	"../symbol.h"


# define 	QTREE		struct querytree


QTREE	*gettree();	/* gets a tree from "tree" catalog [readtree.c] */

char	*Days []
{
	"sunday",
	"monday",
	"tuesday",
	"wednesday",
	"thursday",
	"friday",
	"saturday",
};

# define	QTREE		struct querytree

struct rngtab
{
	char	relid [MAXNAME];
	char	rowner [2];
	char	rused;
}; 

struct rngtab	Rangev[MAXVAR + 1];



/*
**  PR_PROT -- print out protection info on a relation
**
**	Prints out a "define permit" statement for 
**	each permission on a relation.
**	First calls pr_spec_permit() to print permissions
**	indicated in the relation.relstat bits. Lower level pr_??
**	routines look for these bits, so in the calls to pr_permit
**	for tuples actually gotten from the "protect" catalog,
**	pr_prot sets the relstat bits, thereby suppressing their special
**	meaning (they are inverse bits: 0 means on).
**
**	Parameters:
**		relid -- non-unique relation name used by user in DBU call
**		rel -- relation tuple
**
**	Returns:
**		0 -- some permissions on rel
**		1 -- no permissions on rel
**
**	Side Effects:
**		reads trees from protection catalog
**
**	Requires:
**		pr_permit() -- to generate query from protection tuple
**		pr_spec_permit() -- to print out relstat generated permissions
**
**	Called By:
**		disp() [display.c]
**
**	Trace Flags:
**		11, 0
**
**	Syserrs:
**		on bad returns from find(), get(), and openr()
**
**	History:
**		11/15/78 -- (marc) written
**		12/19/78 -- (marc) modified to take into account S_PROT[12]
**		1/9/79 -- (marc)    "		"	    "	S_PROT[ALL,RET]
*/

pr_prot(relid, rel)
char			*relid;
struct relation		*rel;
{
	extern struct descriptor	Prodes;
	struct tup_id			hitid, lotid;
	struct protect			key, tuple;
	register			i;
	int				flag;	/* indicates wether a special
						 * case occurred
						 */
	register struct relation	*r;

#	ifdef xZTR1
	if (tTf(11, 0))
		printf("pr_prot: relation \"%s\" owner \"%s\"relstat 0%o\n",
		rel->relid, rel->relowner, rel->relstat);
#	endif

	r = rel;
	flag = 0;
	if (r->relstat & S_PROTUPS || !(r->relstat & S_PROTALL)
	   || !(r->relstat & S_PROTRET))
		printf("Permissions on %s are:\n\n", relid);
	/* print out special permissions, if any */
	flag =+ pr_spec_permit(r, S_PROTALL);
	flag =+ pr_spec_permit(r, S_PROTRET);

	if (!(r->relstat & S_PROTUPS))
		if (flag)
			return (0);
		else
			return (1);
	opencatalog("protect", 0);
	
	/* get protect catalog tuples for "r", "owner" */
	clearkeys(&Prodes);
	setkey(&Prodes, &key, r->relid, PRORELID);
	setkey(&Prodes, &key, r->relowner, PRORELOWN);
	if (i = find(&Prodes, EXACTKEY, &lotid, &hitid, &key))
		syserr("pr_prot: find %d", i);
	/* ready for pr_user call to getuser() */
	getuser(-1);
	for ( ; ; )
	{
		if (i = get(&Prodes, &lotid, &hitid, &tuple, TRUE))
			break;
		/* print out protection info */
		if (kcompare(&Prodes, &tuple, &key) == 0)
			/* permission from real protect tuple, concoct
			 * neutral relstat
			 */
			pr_permit(&tuple, r->relstat | S_PROTALL | S_PROTRET);
	}
	if (i != 1)
		syserr("pr_prot: get %d", i);

	/* close user file opened by pr_user call to getuser */
	getuser(0);
}

/*
**  PR_SPEC_PERMIT -- Print out special permissions
**	Prints out permissios indicated by the relation.relstat field bits.
**	Concocts a protection tuple for the permission and assigns a 
**	propermid-like number to it for printing. Passes to pr_permit()
**	the concocted tuple, together with a relstat where the appropriate
**	bit is 0, so that the special printing at the lower level pr_??? 
**	routines takes place.
**
**	Parameters:
**		rel -- relation relation tuple for the permitted relation
**		relst_bit -- if this bit is 0 inthe relstat, prints the query
**				{S_PROTALL, S_PROTRET}
**
**	Returns:
**		1 -- if prints
**		0 -- otherwise
**
**	Requires:
**		pr_permit()
**
**	Called By:
**		pr_prot()
**
**	Syserrs:
**		relst_bit ! in {S_PROTALL, S_PROTRET}
**
**	History:
**		1/9/79 -- (marc) written to handle S_PROTALL and S_PROTRET
*/


pr_spec_permit(rel, relst_bit)
struct relation		*rel;
int			relst_bit;
{
	register struct relation	*r;
	register struct protect		*p;
	struct protect			prot;

	r = rel;
	if (r->relstat & relst_bit)
		return (0);
	p = &prot;
	p->protree = -1;
	if (relst_bit == S_PROTALL)
		p->propermid = 0;
	else if (relst_bit == S_PROTRET)
		p->propermit = 1;
	else
		syserr("pr_spec_permit(relst_bit == 0%o)", relst_bit);

	bmove(r->relid, p->prorelid, MAXNAME);
	bmove("  ", p->prouser, 2);
	bmove(" ", &p->proterm, 1);
	pr_permit(p, (r->relstat | S_PROTRET | S_PROTALL) & ~relst_bit);
	return (1);
}


/*
**  PR_PERMIT -- print out a DEFINE PERMIT query for a protection tuple
**
**	Parameters:
**		prot -- protection tuple
**		relstat -- relstat from relation
**
**	Returns:
**		none
**
**	Side Effects:
**		reads in a tree from the "tree" catalog
**		prints out a query
**
**	Requires:
**		clrrange(), pr_range() -- to initialize and print range table
**		gettree() -- to read in "tree" tree and fill range table
**		pr_ops(),
**		pr_doms(),
**		pr_user(),
**		pr_term(),
**		pr_time(),
**		pr_day() -- to print out parts of query
**		pr_qual() -- [pr_tree.c] to print out qualification
**
**	Called By:
**		pr_prot()
**		pr_spec_permit()
**
**	Trace Flags:
**		11, 1
**
**	History:
**		11/15/78 -- (marc) written
**		12/19/78 -- (marc) changed to deal with relstat
**		1/9/79 -- (marc)    "		"	  "
*/


pr_permit(prot, relstat)
struct protect	*prot;
int		relstat;
{
	register struct protect		*p;
	register QTREE			*t;
	extern int			Resultvar;
	extern struct descriptor	Prodes;

	p = prot;
	/* 
	 * if there is a qualification then
	 * clear range table, then read in protect tree, 
	 * the print out range statements
	 * else create single entry range table.
	 */
	clrrange();
	if (p->protree >= 0)
		t = gettree(p->prorelid, p->prorelown, mdPROT, p->protree);
	else
	{
		t = 0;
		declare(0, p->prorelid, p->prorelown);
		p->proresvar = 0;
	}
	printf("Permission %d -\n\n", p->propermid);
	pr_range();

#	ifdef xZTR1
	if (tTf(11, 1))
	{
		printf("pr_permit: prot=");
		printup(&Prodes, p);
		printf(", Resultvar=%d\n", Resultvar);
	}
#	endif

	/* print out query */
	printf("define permit ");
	pr_ops(p->proopset, relstat);
	printf("on ");
	pr_rv(Resultvar = p->proresvar);
	putchar(' ');
	pr_doms(p->prodomset, relstat);
	printf("\n\t");
	pr_user(p->prouser);
	pr_term(p->proterm);
	if ((relstat & S_PROTRET) && (relstat & S_PROTALL))
	{
		/* not special case */
		pr_time(p->protodbgn, p->protodend);
		pr_day(p->prodowbgn, p->prodowend);
	}
	if (t && t->right != QLEND)
	{
		printf("\nwhere ");
		pr_qual(t->right);
	}
	printf("\n\n\n");
}

/*
**  PR_OPS -- Prints the the operation list defined by a protection opset
**
**	Eliminates the appropriate bits from a copy of the opset while printing
**	out the appropriate operation list.
**
**	Parameters:
**		opset -- protection.opset for the relation
**		relstat
**
**	Returns:
**		none
**
**	Side Effects:
**		printing of permitted op list
**
**	Called By:
**		pr_permit()
**
**	Trace Flags:
**		11, 2
**
**
**	History:
**		11/15/78 -- (marc) written
**		12/19/78 -- (marc) relstat added
**		1/9/79 -- (marc) S_PROTALL and S_PROTRET handled
*/

pr_ops(opset, relstat)
int		opset;
int		relstat;
{
	register	op, j;

#	ifdef xZTR1
	if (tTf(11, 2))
		printf("pr_ops(0%o)\n", opset);
#	endif

	if (!(relstat & S_PROTALL) || opset == -1)
	{
		printf("all ");
		return;
	}
	if (!(relstat & S_PROTRET))
	{
		printf("retrieve ");
		return;
	}

	op = (opset & ~PRO_AGGR & ~PRO_TEST) & 077;
	for ( ; ; )
	{
		if (op & (j = PRO_RETR))
			printf("retrieve");
		else if (op & (j = PRO_REPL))
			printf("replace");
		else if (op & (j = PRO_DEL))
			printf("delete");
		else if (op & (j = PRO_APP))
			printf("append");
		op =^ j;
		if (op)
			printf(", ");
		else
			break;
	}
	putchar(' ');
}

/*
**  PR_DOMS -- Print domains in permit target list
**
**	Parameters:
**		doms -- an 8 byte integer array; a bit map of the domains
**			if all 8 integers are -1, then "all" is printed fo
**			for the target list
**		relstat
**
**	Returns:
**		none
**
**	Side Effects:
**		prints out target list
**
**	Requires:
**		pr_attname() -- to print out names given relation 
**				and domain number
**
**	Called By:
**		pr_permit()
**
**	Trace Flags:
**		11, 3
**
**	History:
**		11/15/78 -- (marc) written
**		1/9/79 -- (marc) modified so will assume all domains if
**			special permission
**		5/22/79 -- (marc) changed so bit of first word is unused
*/

pr_doms(doms, relstat)
int	doms [8];
int	relstat;
{
	register int		*d;
	register int		flag, shift;
	int			word;
	char			*rel;
	extern int		Resultvar;

	word = shift = 0;
	d = doms;
	rel = Rangev [Resultvar].relid;

#	ifdef xZTR1
	if (tTf(11, 3))
	{
		printf("pr_doms: rel=\"%s\" ", rel);
		for (word = 0; word < 8; )
			printf("0%o ", d [word++]);
		word = 0;
		putchar('\n');
	}
#	endif
	if (!(relstat & S_PROTALL) || !(relstat & S_PROTRET))
		return;
	flag = 1;
	for (word = 0; word < 8; word++)
		if (*d++ != -1)
		{
			flag = 0;
			break;
		}

	if (!flag)
	{
		putchar('(');
		for (d = doms, word = 0; word < 8; word++, d++)
		{
			for (shift = 0; shift < 16; shift++, *d =>> 1)
			{
				if (*d & 01)
				{
					if (flag++)
						printf(", ");
					pr_attname(rel, word * 16 + shift);
				}
			}
		}
		putchar(')');
	}
}

/*
**  PR_USER -- prints out permitted user's name
**
**	Parameters:
**		user -- 2 char array, user's usercode as in
**			users file
**
**	Returns:
**		none
**
**	Side Effects:
**		prints users name or "all" if user was "  "
**
**	Requires:
**		getuser(UTIL) -- to get user login name.
**
**	Called By:
**		pr_permit()
**
**	Trace Flags:
**		11, 4
**
**	History:
**		11/15/78 -- (marc) written
*/

pr_user(user)
char		user [2];
{
	register		i;
	char			buf [512];
	register char		*c, *u;
	
#	ifdef xZTR1
	if (tTf(11, 4))
		printf("pr_user(\"%c%c\")\n", user [0], user [1]);
#	endif

	c = buf;
	u = user;
	printf("to ");
	if (bequal(u, "  ", 2))
		printf("all ");
	else
	{
		if (getuser(u, c))
		{
			printf("%c%c ", u[0], u[1]);
			return;
		}
		while (*c != ':' && *c != '\n')
			putchar(*c++);
		putchar(' ');
	}
}

/*
**  PR_TIME -- Prints out clock time range access is allowed
**
**	Parameters:
**		bgn, end -- begin end times in seconds (if all day, returns)
**
**	Returns:
**		none
**
**	Side Effects:
**		prints out time
**
**	Called By:
**		pr_permit()
**
**	Trace Flags:
**		11, 5
**
**	History:
**		11/15/78 -- (marc) written
*/

pr_time(bgn, end)
int		bgn, end;
{
	char		time [3];
	register char	*t;
	register int	b, e;

	t = time;
	b = bgn;
	e = end;
#	ifdef xZTR1
	if (tTf(11, 5))
		printf("pr_time(bgn=%d, end=%d)\n", b, e);
#	endif
	if (b == 0 && e == 24 * 60)
		return;
	printf("from %d:", b / 60);
	itoa(b % 60, t);
	if (!t [1])
		putchar('0');
	printf("%s to %d:", t, e / 60);
	itoa(e % 60, t);
	if (!t [1])
		putchar('0');
	printf("%s ", t);
}

/*
**  PR_DAY -- Prints day range permitted
**
**	Parameters:
**		bgn, end -- bgn end days [0..6] (if all week returns)
**
**	Returns:
**		none
**
**	Side Effects:
**		prints days or nothing
**
**	Requires:
**		Days [0..6] -- string array of day names
**
**	Called By:
**		pr_permit()
**
**	Trace Flags:
**		11, 6
**
**	History:
**		11/15/78 -- (marc) written
*/

pr_day(bgn, end)
int		bgn, end;
{
#	ifdef xZTR1
	if (tTf(11, 6))
		printf("pr_day(bgn=%d, end=%d)\n", bgn, end);
#	endif
	if (bgn == 0 && end >= 6)
		return;
	printf("on %s to %s ", Days [bgn], Days [end]);
}

/*
**  PR_TERM -- Print terminal from which access permitted
**
**	Parameters:
**		term -- 1 char terminal id as in /etc/tty* (if ' ' the returns)
**
**	Returns:
**		none
**
**	Side Effects:
**		prints terminal or nothing
**
**	Called By:
**		pr_permit()
**
**	Trace Flags:
**		11, 7
**
**	History:
**		11/15/78 -- (marc) written
*/

pr_term(term)
# ifdef	xV7_UNIX
char		*term;
# endif
# ifndef xV7_UNIX
char		term;
# endif
{
#	ifdef xZTR1
	if (tTf(11, 7))
# ifdef xV7_UNIX
		printf("pr_trem(term='%2s')\n", term);
# endif
# ifndef xV7_UNIX
		printf("pr_trem(term='%c')\n", term);
# endif
#	endif

# ifndef xV7_UNIX
	if (term != ' ')
		printf("at tty%c ", term);
# endif
# ifdef xV7_UNIX
	if (*term != ' ')
		printf("at tty%2s", term);
# endif
}