1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* aclchk.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* Routines to check access control permissions.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2002-06-20 22:29:54 +02:00
|
|
|
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2002-07-20 07:16:59 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.71 2002/07/20 05:16:56 momjian Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
* NOTES
|
1997-09-07 07:04:48 +02:00
|
|
|
* See acl.h.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
1996-11-03 07:54:38 +01:00
|
|
|
#include "postgres.h"
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "access/heapam.h"
|
|
|
|
#include "catalog/catalog.h"
|
|
|
|
#include "catalog/catname.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "catalog/indexing.h"
|
2002-03-26 20:17:02 +01:00
|
|
|
#include "catalog/namespace.h"
|
2002-04-21 02:26:44 +02:00
|
|
|
#include "catalog/pg_database.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "catalog/pg_group.h"
|
2002-02-19 00:11:58 +01:00
|
|
|
#include "catalog/pg_language.h"
|
2002-04-21 02:26:44 +02:00
|
|
|
#include "catalog/pg_namespace.h"
|
1996-10-31 06:55:24 +01:00
|
|
|
#include "catalog/pg_operator.h"
|
1996-11-08 07:02:30 +01:00
|
|
|
#include "catalog/pg_proc.h"
|
1998-02-25 14:09:49 +01:00
|
|
|
#include "catalog/pg_shadow.h"
|
1998-04-27 06:08:07 +02:00
|
|
|
#include "catalog/pg_type.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "miscadmin.h"
|
1997-11-25 23:07:18 +01:00
|
|
|
#include "parser/parse_func.h"
|
1999-07-16 07:00:38 +02:00
|
|
|
#include "utils/acl.h"
|
2002-04-21 02:26:44 +02:00
|
|
|
#include "utils/fmgroids.h"
|
|
|
|
#include "utils/lsyscache.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
#include "utils/syscache.h"
|
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
static void ExecuteGrantStmt_Relation(GrantStmt *stmt);
|
|
|
|
static void ExecuteGrantStmt_Database(GrantStmt *stmt);
|
2002-02-19 00:11:58 +01:00
|
|
|
static void ExecuteGrantStmt_Function(GrantStmt *stmt);
|
2002-04-21 02:26:44 +02:00
|
|
|
static void ExecuteGrantStmt_Language(GrantStmt *stmt);
|
|
|
|
static void ExecuteGrantStmt_Namespace(GrantStmt *stmt);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
static const char *privilege_to_string(AclMode privilege);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
2002-04-27 05:45:03 +02:00
|
|
|
static AclResult aclcheck(Acl *acl, AclId id, uint32 idtype, AclMode mode);
|
1997-03-12 21:48:48 +01:00
|
|
|
|
2000-10-02 06:49:28 +02:00
|
|
|
|
2001-05-27 11:59:30 +02:00
|
|
|
#ifdef ACLDEBUG
|
1996-07-09 08:22:35 +02:00
|
|
|
static
|
1997-09-08 22:59:27 +02:00
|
|
|
dumpacl(Acl *acl)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2000-08-01 00:39:17 +02:00
|
|
|
int i;
|
1997-09-08 04:41:22 +02:00
|
|
|
AclItem *aip;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "acl size = %d, # acls = %d",
|
1997-09-07 07:04:48 +02:00
|
|
|
ACL_SIZE(acl), ACL_NUM(acl));
|
2000-08-01 00:39:17 +02:00
|
|
|
aip = ACL_DAT(acl);
|
1997-09-07 07:04:48 +02:00
|
|
|
for (i = 0; i < ACL_NUM(acl); ++i)
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, " acl[%d]: %s", i,
|
2000-08-01 00:39:17 +02:00
|
|
|
DatumGetCString(DirectFunctionCall1(aclitemout,
|
2001-03-22 05:01:46 +01:00
|
|
|
PointerGetDatum(aip + i))));
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
2001-11-05 18:46:40 +01:00
|
|
|
#endif /* ACLDEBUG */
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
/*
|
|
|
|
* If is_grant is true, adds the given privileges for the list of
|
|
|
|
* grantees to the existing old_acl. If is_grant is false, the
|
|
|
|
* privileges for the given grantees are removed from old_acl.
|
|
|
|
*/
|
2002-04-21 02:26:44 +02:00
|
|
|
static Acl *
|
|
|
|
merge_acl_with_grant(Acl *old_acl, bool is_grant,
|
|
|
|
List *grantees, AclMode privileges)
|
2002-02-19 00:11:58 +01:00
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
unsigned modechg;
|
2002-02-19 00:11:58 +01:00
|
|
|
List *j;
|
|
|
|
Acl *new_acl;
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
modechg = is_grant ? ACL_MODECHG_ADD : ACL_MODECHG_DEL;
|
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
#ifdef ACLDEBUG
|
|
|
|
dumpacl(old_acl);
|
|
|
|
#endif
|
|
|
|
new_acl = old_acl;
|
|
|
|
|
|
|
|
foreach(j, grantees)
|
|
|
|
{
|
|
|
|
PrivGrantee *grantee = (PrivGrantee *) lfirst(j);
|
2002-04-21 02:26:44 +02:00
|
|
|
AclItem aclitem;
|
|
|
|
uint32 idtype;
|
2002-02-19 00:11:58 +01:00
|
|
|
|
|
|
|
if (grantee->username)
|
2002-04-21 02:26:44 +02:00
|
|
|
{
|
|
|
|
aclitem.ai_id = get_usesysid(grantee->username);
|
|
|
|
idtype = ACL_IDTYPE_UID;
|
|
|
|
}
|
2002-02-19 00:11:58 +01:00
|
|
|
else if (grantee->groupname)
|
2002-04-21 02:26:44 +02:00
|
|
|
{
|
|
|
|
aclitem.ai_id = get_grosysid(grantee->groupname);
|
|
|
|
idtype = ACL_IDTYPE_GID;
|
|
|
|
}
|
2002-02-19 00:11:58 +01:00
|
|
|
else
|
2002-04-21 02:26:44 +02:00
|
|
|
{
|
|
|
|
aclitem.ai_id = ACL_ID_WORLD;
|
|
|
|
idtype = ACL_IDTYPE_WORLD;
|
|
|
|
}
|
2002-02-19 00:11:58 +01:00
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
ACLITEM_SET_PRIVS_IDTYPE(aclitem, privileges, idtype);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
|
|
|
new_acl = aclinsert3(new_acl, &aclitem, modechg);
|
|
|
|
|
|
|
|
#ifdef ACLDEBUG
|
|
|
|
dumpacl(new_acl);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
return new_acl;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
2001-06-10 01:21:55 +02:00
|
|
|
* Called to execute the utility commands GRANT and REVOKE
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
void
|
2001-06-10 01:21:55 +02:00
|
|
|
ExecuteGrantStmt(GrantStmt *stmt)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
switch (stmt->objtype)
|
2002-02-19 00:11:58 +01:00
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
case ACL_OBJECT_RELATION:
|
|
|
|
ExecuteGrantStmt_Relation(stmt);
|
|
|
|
break;
|
|
|
|
case ACL_OBJECT_DATABASE:
|
|
|
|
ExecuteGrantStmt_Database(stmt);
|
2002-02-19 00:11:58 +01:00
|
|
|
break;
|
2002-04-21 02:26:44 +02:00
|
|
|
case ACL_OBJECT_FUNCTION:
|
2002-02-19 00:11:58 +01:00
|
|
|
ExecuteGrantStmt_Function(stmt);
|
|
|
|
break;
|
2002-04-21 02:26:44 +02:00
|
|
|
case ACL_OBJECT_LANGUAGE:
|
|
|
|
ExecuteGrantStmt_Language(stmt);
|
|
|
|
break;
|
|
|
|
case ACL_OBJECT_NAMESPACE:
|
|
|
|
ExecuteGrantStmt_Namespace(stmt);
|
2002-02-19 00:11:58 +01:00
|
|
|
break;
|
|
|
|
default:
|
2002-04-21 02:26:44 +02:00
|
|
|
elog(ERROR, "bogus GrantStmt.objtype %d", (int) stmt->objtype);
|
2002-02-19 00:11:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2002-04-21 02:26:44 +02:00
|
|
|
ExecuteGrantStmt_Relation(GrantStmt *stmt)
|
2002-02-19 00:11:58 +01:00
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
AclMode privileges;
|
2002-02-19 00:11:58 +01:00
|
|
|
List *i;
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
if (lfirsti(stmt->privileges) == ACL_ALL_RIGHTS)
|
|
|
|
privileges = ACL_ALL_RIGHTS_RELATION;
|
2002-02-19 00:11:58 +01:00
|
|
|
else
|
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
privileges = ACL_NO_RIGHTS;
|
2002-02-19 00:11:58 +01:00
|
|
|
foreach(i, stmt->privileges)
|
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
AclMode priv = lfirsti(i);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
if (priv & ~((AclMode) ACL_ALL_RIGHTS_RELATION))
|
|
|
|
elog(ERROR, "invalid privilege type %s for table object",
|
|
|
|
privilege_to_string(priv));
|
|
|
|
privileges |= priv;
|
2002-02-19 00:11:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach(i, stmt->objects)
|
2000-08-01 00:39:17 +02:00
|
|
|
{
|
2002-03-26 20:17:02 +01:00
|
|
|
RangeVar *relvar = (RangeVar *) lfirst(i);
|
|
|
|
Oid relOid;
|
2001-06-10 01:21:55 +02:00
|
|
|
Relation relation;
|
|
|
|
HeapTuple tuple;
|
|
|
|
Form_pg_class pg_class_tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *old_acl;
|
|
|
|
Acl *new_acl;
|
|
|
|
HeapTuple newtuple;
|
|
|
|
Datum values[Natts_pg_class];
|
|
|
|
char nulls[Natts_pg_class];
|
|
|
|
char replaces[Natts_pg_class];
|
|
|
|
|
|
|
|
/* open pg_class */
|
|
|
|
relation = heap_openr(RelationRelationName, RowExclusiveLock);
|
2002-03-26 20:17:02 +01:00
|
|
|
relOid = RangeVarGetRelid(relvar, false);
|
|
|
|
tuple = SearchSysCache(RELOID,
|
|
|
|
ObjectIdGetDatum(relOid),
|
2001-06-10 01:21:55 +02:00
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
2002-03-26 20:17:02 +01:00
|
|
|
elog(ERROR, "relation %u not found", relOid);
|
2001-06-10 01:21:55 +02:00
|
|
|
pg_class_tuple = (Form_pg_class) GETSTRUCT(tuple);
|
|
|
|
|
2002-03-26 20:17:02 +01:00
|
|
|
if (!pg_class_ownercheck(relOid, GetUserId()))
|
2002-04-27 05:45:03 +02:00
|
|
|
aclcheck_error(ACLCHECK_NOT_OWNER, relvar->relname);
|
2002-03-22 00:27:25 +01:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
if (pg_class_tuple->relkind == RELKIND_INDEX)
|
|
|
|
elog(ERROR, "\"%s\" is an index",
|
2002-03-26 20:17:02 +01:00
|
|
|
relvar->relname);
|
2001-06-10 01:21:55 +02:00
|
|
|
|
|
|
|
/*
|
2001-10-25 07:50:21 +02:00
|
|
|
* If there's no ACL, create a default using the pg_class.relowner
|
|
|
|
* field.
|
2001-06-10 01:21:55 +02:00
|
|
|
*/
|
2002-03-26 20:17:02 +01:00
|
|
|
aclDatum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relacl,
|
2001-06-10 01:21:55 +02:00
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
2002-04-21 02:26:44 +02:00
|
|
|
old_acl = acldefault(ACL_OBJECT_RELATION,
|
|
|
|
pg_class_tuple->relowner);
|
2001-06-10 01:21:55 +02:00
|
|
|
else
|
2002-04-21 02:26:44 +02:00
|
|
|
/* get a detoasted copy of the ACL */
|
2001-06-10 01:21:55 +02:00
|
|
|
old_acl = DatumGetAclPCopy(aclDatum);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
new_acl = merge_acl_with_grant(old_acl, stmt->is_grant,
|
2002-04-21 02:26:44 +02:00
|
|
|
stmt->grantees, privileges);
|
2001-06-10 01:21:55 +02:00
|
|
|
|
|
|
|
/* finished building new ACL value, now insert it */
|
2002-04-21 02:26:44 +02:00
|
|
|
MemSet(values, 0, sizeof(values));
|
|
|
|
MemSet(nulls, ' ', sizeof(nulls));
|
|
|
|
MemSet(replaces, ' ', sizeof(replaces));
|
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
replaces[Anum_pg_class_relacl - 1] = 'r';
|
|
|
|
values[Anum_pg_class_relacl - 1] = PointerGetDatum(new_acl);
|
2002-04-21 02:26:44 +02:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
newtuple = heap_modifytuple(tuple, relation, values, nulls, replaces);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
ReleaseSysCache(tuple);
|
2000-11-16 23:30:52 +01:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
simple_heap_update(relation, &newtuple->t_self, newtuple);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
{
|
|
|
|
/* keep the catalog indexes up to date */
|
|
|
|
Relation idescs[Num_pg_class_indices];
|
2001-10-25 07:50:21 +02:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
CatalogOpenIndices(Num_pg_class_indices, Name_pg_class_indices,
|
|
|
|
idescs);
|
|
|
|
CatalogIndexInsert(idescs, Num_pg_class_indices, relation, newtuple);
|
|
|
|
CatalogCloseIndices(Num_pg_class_indices, idescs);
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
pfree(old_acl);
|
|
|
|
pfree(new_acl);
|
2000-10-02 06:49:28 +02:00
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
heap_close(relation, RowExclusiveLock);
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
static void
|
|
|
|
ExecuteGrantStmt_Database(GrantStmt *stmt)
|
|
|
|
{
|
|
|
|
AclMode privileges;
|
|
|
|
List *i;
|
|
|
|
|
|
|
|
if (lfirsti(stmt->privileges) == ACL_ALL_RIGHTS)
|
|
|
|
privileges = ACL_ALL_RIGHTS_DATABASE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
privileges = ACL_NO_RIGHTS;
|
|
|
|
foreach(i, stmt->privileges)
|
|
|
|
{
|
|
|
|
AclMode priv = lfirsti(i);
|
|
|
|
|
|
|
|
if (priv & ~((AclMode) ACL_ALL_RIGHTS_DATABASE))
|
|
|
|
elog(ERROR, "invalid privilege type %s for database object",
|
|
|
|
privilege_to_string(priv));
|
|
|
|
privileges |= priv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach(i, stmt->objects)
|
|
|
|
{
|
|
|
|
char *dbname = strVal(lfirst(i));
|
|
|
|
Relation relation;
|
|
|
|
ScanKeyData entry[1];
|
|
|
|
HeapScanDesc scan;
|
|
|
|
HeapTuple tuple;
|
|
|
|
Form_pg_database pg_database_tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *old_acl;
|
|
|
|
Acl *new_acl;
|
|
|
|
HeapTuple newtuple;
|
|
|
|
Datum values[Natts_pg_database];
|
|
|
|
char nulls[Natts_pg_database];
|
|
|
|
char replaces[Natts_pg_database];
|
|
|
|
|
|
|
|
relation = heap_openr(DatabaseRelationName, RowExclusiveLock);
|
|
|
|
ScanKeyEntryInitialize(&entry[0], 0,
|
|
|
|
Anum_pg_database_datname, F_NAMEEQ,
|
|
|
|
CStringGetDatum(dbname));
|
2002-05-21 01:51:44 +02:00
|
|
|
scan = heap_beginscan(relation, SnapshotNow, 1, entry);
|
|
|
|
tuple = heap_getnext(scan, ForwardScanDirection);
|
2002-04-21 02:26:44 +02:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "database \"%s\" not found", dbname);
|
|
|
|
pg_database_tuple = (Form_pg_database) GETSTRUCT(tuple);
|
|
|
|
|
|
|
|
if (!superuser() && pg_database_tuple->datdba != GetUserId())
|
|
|
|
elog(ERROR, "permission denied");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's no ACL, create a default.
|
|
|
|
*/
|
|
|
|
aclDatum = heap_getattr(tuple, Anum_pg_database_datacl,
|
|
|
|
RelationGetDescr(relation), &isNull);
|
|
|
|
if (isNull)
|
|
|
|
old_acl = acldefault(ACL_OBJECT_DATABASE,
|
|
|
|
pg_database_tuple->datdba);
|
|
|
|
else
|
|
|
|
/* get a detoasted copy of the ACL */
|
|
|
|
old_acl = DatumGetAclPCopy(aclDatum);
|
|
|
|
|
|
|
|
new_acl = merge_acl_with_grant(old_acl, stmt->is_grant,
|
|
|
|
stmt->grantees, privileges);
|
|
|
|
|
|
|
|
/* finished building new ACL value, now insert it */
|
|
|
|
MemSet(values, 0, sizeof(values));
|
|
|
|
MemSet(nulls, ' ', sizeof(nulls));
|
|
|
|
MemSet(replaces, ' ', sizeof(replaces));
|
|
|
|
|
|
|
|
replaces[Anum_pg_database_datacl - 1] = 'r';
|
|
|
|
values[Anum_pg_database_datacl - 1] = PointerGetDatum(new_acl);
|
|
|
|
|
|
|
|
newtuple = heap_modifytuple(tuple, relation, values, nulls, replaces);
|
|
|
|
|
|
|
|
simple_heap_update(relation, &newtuple->t_self, newtuple);
|
|
|
|
|
|
|
|
{
|
|
|
|
/* keep the catalog indexes up to date */
|
|
|
|
Relation idescs[Num_pg_database_indices];
|
|
|
|
|
|
|
|
CatalogOpenIndices(Num_pg_database_indices, Name_pg_database_indices,
|
|
|
|
idescs);
|
|
|
|
CatalogIndexInsert(idescs, Num_pg_database_indices, relation, newtuple);
|
|
|
|
CatalogCloseIndices(Num_pg_database_indices, idescs);
|
|
|
|
}
|
|
|
|
|
|
|
|
pfree(old_acl);
|
|
|
|
pfree(new_acl);
|
|
|
|
|
|
|
|
heap_endscan(scan);
|
|
|
|
|
|
|
|
heap_close(relation, RowExclusiveLock);
|
|
|
|
}
|
|
|
|
}
|
2001-06-10 01:21:55 +02:00
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
static void
|
|
|
|
ExecuteGrantStmt_Function(GrantStmt *stmt)
|
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
AclMode privileges;
|
2002-02-19 00:11:58 +01:00
|
|
|
List *i;
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
if (lfirsti(stmt->privileges) == ACL_ALL_RIGHTS)
|
|
|
|
privileges = ACL_ALL_RIGHTS_FUNCTION;
|
2002-02-19 00:11:58 +01:00
|
|
|
else
|
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
privileges = ACL_NO_RIGHTS;
|
2002-02-19 00:11:58 +01:00
|
|
|
foreach(i, stmt->privileges)
|
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
AclMode priv = lfirsti(i);
|
|
|
|
|
|
|
|
if (priv & ~((AclMode) ACL_ALL_RIGHTS_FUNCTION))
|
2002-02-19 00:11:58 +01:00
|
|
|
elog(ERROR, "invalid privilege type %s for function object",
|
2002-04-21 02:26:44 +02:00
|
|
|
privilege_to_string(priv));
|
|
|
|
privileges |= priv;
|
2002-02-19 00:11:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach(i, stmt->objects)
|
|
|
|
{
|
|
|
|
FuncWithArgs *func = (FuncWithArgs *) lfirst(i);
|
|
|
|
Oid oid;
|
|
|
|
Relation relation;
|
|
|
|
HeapTuple tuple;
|
|
|
|
Form_pg_proc pg_proc_tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *old_acl;
|
|
|
|
Acl *new_acl;
|
|
|
|
HeapTuple newtuple;
|
|
|
|
Datum values[Natts_pg_proc];
|
|
|
|
char nulls[Natts_pg_proc];
|
|
|
|
char replaces[Natts_pg_proc];
|
|
|
|
|
2002-04-09 22:35:55 +02:00
|
|
|
oid = LookupFuncNameTypeNames(func->funcname, func->funcargs,
|
2002-07-18 06:50:10 +02:00
|
|
|
true, stmt->is_grant ? "GRANT" : "REVOKE");
|
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
relation = heap_openr(ProcedureRelationName, RowExclusiveLock);
|
2002-04-21 02:26:44 +02:00
|
|
|
tuple = SearchSysCache(PROCOID,
|
|
|
|
ObjectIdGetDatum(oid),
|
|
|
|
0, 0, 0);
|
2002-02-19 00:11:58 +01:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "function %u not found", oid);
|
|
|
|
pg_proc_tuple = (Form_pg_proc) GETSTRUCT(tuple);
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
if (!pg_proc_ownercheck(oid, GetUserId()))
|
2002-04-27 05:45:03 +02:00
|
|
|
aclcheck_error(ACLCHECK_NOT_OWNER,
|
|
|
|
NameStr(pg_proc_tuple->proname));
|
2002-02-19 00:11:58 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's no ACL, create a default using the pg_proc.proowner
|
|
|
|
* field.
|
|
|
|
*/
|
|
|
|
aclDatum = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_proacl,
|
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
2002-04-21 02:26:44 +02:00
|
|
|
old_acl = acldefault(ACL_OBJECT_FUNCTION,
|
|
|
|
pg_proc_tuple->proowner);
|
2002-02-19 00:11:58 +01:00
|
|
|
else
|
2002-04-21 02:26:44 +02:00
|
|
|
/* get a detoasted copy of the ACL */
|
2002-02-19 00:11:58 +01:00
|
|
|
old_acl = DatumGetAclPCopy(aclDatum);
|
|
|
|
|
|
|
|
new_acl = merge_acl_with_grant(old_acl, stmt->is_grant,
|
2002-04-21 02:26:44 +02:00
|
|
|
stmt->grantees, privileges);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
|
|
|
/* finished building new ACL value, now insert it */
|
2002-04-21 02:26:44 +02:00
|
|
|
MemSet(values, 0, sizeof(values));
|
|
|
|
MemSet(nulls, ' ', sizeof(nulls));
|
|
|
|
MemSet(replaces, ' ', sizeof(replaces));
|
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
replaces[Anum_pg_proc_proacl - 1] = 'r';
|
|
|
|
values[Anum_pg_proc_proacl - 1] = PointerGetDatum(new_acl);
|
2002-04-21 02:26:44 +02:00
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
newtuple = heap_modifytuple(tuple, relation, values, nulls, replaces);
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
simple_heap_update(relation, &newtuple->t_self, newtuple);
|
|
|
|
|
|
|
|
{
|
|
|
|
/* keep the catalog indexes up to date */
|
|
|
|
Relation idescs[Num_pg_proc_indices];
|
|
|
|
|
|
|
|
CatalogOpenIndices(Num_pg_proc_indices, Name_pg_proc_indices,
|
|
|
|
idescs);
|
|
|
|
CatalogIndexInsert(idescs, Num_pg_proc_indices, relation, newtuple);
|
|
|
|
CatalogCloseIndices(Num_pg_proc_indices, idescs);
|
|
|
|
}
|
|
|
|
|
|
|
|
pfree(old_acl);
|
|
|
|
pfree(new_acl);
|
|
|
|
|
|
|
|
heap_close(relation, RowExclusiveLock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2002-04-21 02:26:44 +02:00
|
|
|
ExecuteGrantStmt_Language(GrantStmt *stmt)
|
2002-02-19 00:11:58 +01:00
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
AclMode privileges;
|
2002-02-19 00:11:58 +01:00
|
|
|
List *i;
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
if (lfirsti(stmt->privileges) == ACL_ALL_RIGHTS)
|
|
|
|
privileges = ACL_ALL_RIGHTS_LANGUAGE;
|
2002-02-19 00:11:58 +01:00
|
|
|
else
|
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
privileges = ACL_NO_RIGHTS;
|
2002-02-19 00:11:58 +01:00
|
|
|
foreach(i, stmt->privileges)
|
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
AclMode priv = lfirsti(i);
|
|
|
|
|
|
|
|
if (priv & ~((AclMode) ACL_ALL_RIGHTS_LANGUAGE))
|
2002-02-19 00:11:58 +01:00
|
|
|
elog(ERROR, "invalid privilege type %s for language object",
|
2002-04-21 02:26:44 +02:00
|
|
|
privilege_to_string(priv));
|
|
|
|
privileges |= priv;
|
2002-02-19 00:11:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach(i, stmt->objects)
|
|
|
|
{
|
|
|
|
char *langname = strVal(lfirst(i));
|
|
|
|
Relation relation;
|
|
|
|
HeapTuple tuple;
|
|
|
|
Form_pg_language pg_language_tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *old_acl;
|
|
|
|
Acl *new_acl;
|
|
|
|
HeapTuple newtuple;
|
|
|
|
Datum values[Natts_pg_language];
|
|
|
|
char nulls[Natts_pg_language];
|
|
|
|
char replaces[Natts_pg_language];
|
|
|
|
|
|
|
|
if (!superuser())
|
|
|
|
elog(ERROR, "permission denied");
|
|
|
|
|
|
|
|
relation = heap_openr(LanguageRelationName, RowExclusiveLock);
|
2002-04-21 02:26:44 +02:00
|
|
|
tuple = SearchSysCache(LANGNAME,
|
|
|
|
PointerGetDatum(langname),
|
|
|
|
0, 0, 0);
|
2002-02-19 00:11:58 +01:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "language \"%s\" not found", langname);
|
|
|
|
pg_language_tuple = (Form_pg_language) GETSTRUCT(tuple);
|
|
|
|
|
|
|
|
if (!pg_language_tuple->lanpltrusted)
|
|
|
|
elog(ERROR, "language \"%s\" is not trusted", langname);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's no ACL, create a default.
|
|
|
|
*/
|
|
|
|
aclDatum = SysCacheGetAttr(LANGNAME, tuple, Anum_pg_language_lanacl,
|
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
2002-04-21 02:26:44 +02:00
|
|
|
old_acl = acldefault(ACL_OBJECT_LANGUAGE,
|
|
|
|
InvalidOid);
|
2002-02-19 00:11:58 +01:00
|
|
|
else
|
2002-04-21 02:26:44 +02:00
|
|
|
/* get a detoasted copy of the ACL */
|
2002-02-19 00:11:58 +01:00
|
|
|
old_acl = DatumGetAclPCopy(aclDatum);
|
|
|
|
|
|
|
|
new_acl = merge_acl_with_grant(old_acl, stmt->is_grant,
|
2002-04-21 02:26:44 +02:00
|
|
|
stmt->grantees, privileges);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
|
|
|
/* finished building new ACL value, now insert it */
|
2002-04-21 02:26:44 +02:00
|
|
|
MemSet(values, 0, sizeof(values));
|
|
|
|
MemSet(nulls, ' ', sizeof(nulls));
|
|
|
|
MemSet(replaces, ' ', sizeof(replaces));
|
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
replaces[Anum_pg_language_lanacl - 1] = 'r';
|
|
|
|
values[Anum_pg_language_lanacl - 1] = PointerGetDatum(new_acl);
|
2002-04-21 02:26:44 +02:00
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
newtuple = heap_modifytuple(tuple, relation, values, nulls, replaces);
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
simple_heap_update(relation, &newtuple->t_self, newtuple);
|
|
|
|
|
|
|
|
{
|
|
|
|
/* keep the catalog indexes up to date */
|
|
|
|
Relation idescs[Num_pg_language_indices];
|
|
|
|
|
|
|
|
CatalogOpenIndices(Num_pg_language_indices, Name_pg_language_indices,
|
|
|
|
idescs);
|
|
|
|
CatalogIndexInsert(idescs, Num_pg_language_indices, relation, newtuple);
|
|
|
|
CatalogCloseIndices(Num_pg_language_indices, idescs);
|
|
|
|
}
|
|
|
|
|
|
|
|
pfree(old_acl);
|
|
|
|
pfree(new_acl);
|
|
|
|
|
|
|
|
heap_close(relation, RowExclusiveLock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
static void
|
|
|
|
ExecuteGrantStmt_Namespace(GrantStmt *stmt)
|
2002-02-19 00:11:58 +01:00
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
AclMode privileges;
|
|
|
|
List *i;
|
2002-02-19 00:11:58 +01:00
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
if (lfirsti(stmt->privileges) == ACL_ALL_RIGHTS)
|
|
|
|
privileges = ACL_ALL_RIGHTS_NAMESPACE;
|
2002-02-19 00:11:58 +01:00
|
|
|
else
|
2002-04-21 02:26:44 +02:00
|
|
|
{
|
|
|
|
privileges = ACL_NO_RIGHTS;
|
|
|
|
foreach(i, stmt->privileges)
|
|
|
|
{
|
|
|
|
AclMode priv = lfirsti(i);
|
|
|
|
|
|
|
|
if (priv & ~((AclMode) ACL_ALL_RIGHTS_NAMESPACE))
|
|
|
|
elog(ERROR, "invalid privilege type %s for namespace object",
|
|
|
|
privilege_to_string(priv));
|
|
|
|
privileges |= priv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach(i, stmt->objects)
|
|
|
|
{
|
|
|
|
char *nspname = strVal(lfirst(i));
|
|
|
|
Relation relation;
|
|
|
|
HeapTuple tuple;
|
|
|
|
Form_pg_namespace pg_namespace_tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *old_acl;
|
|
|
|
Acl *new_acl;
|
|
|
|
HeapTuple newtuple;
|
|
|
|
Datum values[Natts_pg_namespace];
|
|
|
|
char nulls[Natts_pg_namespace];
|
|
|
|
char replaces[Natts_pg_namespace];
|
|
|
|
|
|
|
|
relation = heap_openr(NamespaceRelationName, RowExclusiveLock);
|
|
|
|
tuple = SearchSysCache(NAMESPACENAME,
|
|
|
|
CStringGetDatum(nspname),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "namespace \"%s\" not found", nspname);
|
|
|
|
pg_namespace_tuple = (Form_pg_namespace) GETSTRUCT(tuple);
|
|
|
|
|
2002-07-20 07:16:59 +02:00
|
|
|
AssertTupleDescHasOid(relation->rd_att);
|
|
|
|
if (!pg_namespace_ownercheck(HeapTupleGetOid(tuple), GetUserId()))
|
2002-04-27 05:45:03 +02:00
|
|
|
aclcheck_error(ACLCHECK_NOT_OWNER, nspname);
|
2002-04-21 02:26:44 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's no ACL, create a default using the pg_namespace.nspowner
|
|
|
|
* field.
|
|
|
|
*/
|
|
|
|
aclDatum = SysCacheGetAttr(NAMESPACENAME, tuple,
|
|
|
|
Anum_pg_namespace_nspacl,
|
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
|
|
|
old_acl = acldefault(ACL_OBJECT_NAMESPACE,
|
|
|
|
pg_namespace_tuple->nspowner);
|
|
|
|
else
|
|
|
|
/* get a detoasted copy of the ACL */
|
|
|
|
old_acl = DatumGetAclPCopy(aclDatum);
|
|
|
|
|
|
|
|
new_acl = merge_acl_with_grant(old_acl, stmt->is_grant,
|
|
|
|
stmt->grantees, privileges);
|
|
|
|
|
|
|
|
/* finished building new ACL value, now insert it */
|
|
|
|
MemSet(values, 0, sizeof(values));
|
|
|
|
MemSet(nulls, ' ', sizeof(nulls));
|
|
|
|
MemSet(replaces, ' ', sizeof(replaces));
|
|
|
|
|
|
|
|
replaces[Anum_pg_namespace_nspacl - 1] = 'r';
|
|
|
|
values[Anum_pg_namespace_nspacl - 1] = PointerGetDatum(new_acl);
|
|
|
|
|
|
|
|
newtuple = heap_modifytuple(tuple, relation, values, nulls, replaces);
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
simple_heap_update(relation, &newtuple->t_self, newtuple);
|
|
|
|
|
|
|
|
{
|
|
|
|
/* keep the catalog indexes up to date */
|
|
|
|
Relation idescs[Num_pg_namespace_indices];
|
|
|
|
|
|
|
|
CatalogOpenIndices(Num_pg_namespace_indices, Name_pg_namespace_indices,
|
|
|
|
idescs);
|
|
|
|
CatalogIndexInsert(idescs, Num_pg_namespace_indices, relation, newtuple);
|
|
|
|
CatalogCloseIndices(Num_pg_namespace_indices, idescs);
|
|
|
|
}
|
|
|
|
|
|
|
|
pfree(old_acl);
|
|
|
|
pfree(new_acl);
|
|
|
|
|
|
|
|
heap_close(relation, RowExclusiveLock);
|
|
|
|
}
|
2002-02-19 00:11:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
static const char *
|
|
|
|
privilege_to_string(AclMode privilege)
|
|
|
|
{
|
|
|
|
switch (privilege)
|
|
|
|
{
|
|
|
|
case ACL_INSERT:
|
|
|
|
return "INSERT";
|
|
|
|
case ACL_SELECT:
|
|
|
|
return "SELECT";
|
|
|
|
case ACL_UPDATE:
|
|
|
|
return "UPDATE";
|
|
|
|
case ACL_DELETE:
|
|
|
|
return "DELETE";
|
|
|
|
case ACL_RULE:
|
|
|
|
return "RULE";
|
|
|
|
case ACL_REFERENCES:
|
|
|
|
return "REFERENCES";
|
|
|
|
case ACL_TRIGGER:
|
|
|
|
return "TRIGGER";
|
|
|
|
case ACL_EXECUTE:
|
|
|
|
return "EXECUTE";
|
|
|
|
case ACL_USAGE:
|
|
|
|
return "USAGE";
|
|
|
|
case ACL_CREATE:
|
|
|
|
return "CREATE";
|
|
|
|
case ACL_CREATE_TEMP:
|
|
|
|
return "TEMP";
|
|
|
|
default:
|
|
|
|
elog(ERROR, "privilege_to_string: unrecognized privilege %d",
|
|
|
|
privilege);
|
|
|
|
}
|
|
|
|
return NULL; /* appease compiler */
|
|
|
|
}
|
|
|
|
|
2001-06-10 01:21:55 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
AclId
|
|
|
|
get_grosysid(char *groname)
|
|
|
|
{
|
1998-08-19 04:04:17 +02:00
|
|
|
HeapTuple tuple;
|
1997-09-08 04:41:22 +02:00
|
|
|
AclId id = 0;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-11-16 23:30:52 +01:00
|
|
|
tuple = SearchSysCache(GRONAME,
|
|
|
|
PointerGetDatum(groname),
|
|
|
|
0, 0, 0);
|
1998-08-19 04:04:17 +02:00
|
|
|
if (HeapTupleIsValid(tuple))
|
2000-11-16 23:30:52 +01:00
|
|
|
{
|
1998-08-19 04:04:17 +02:00
|
|
|
id = ((Form_pg_group) GETSTRUCT(tuple))->grosysid;
|
2000-11-16 23:30:52 +01:00
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
else
|
1998-01-05 17:40:20 +01:00
|
|
|
elog(ERROR, "non-existent group \"%s\"", groname);
|
1998-09-01 05:29:17 +02:00
|
|
|
return id;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2000-11-29 00:42:31 +01:00
|
|
|
/*
|
|
|
|
* Convert group ID to name, or return NULL if group can't be found
|
|
|
|
*/
|
1998-02-26 05:46:47 +01:00
|
|
|
char *
|
1996-07-09 08:22:35 +02:00
|
|
|
get_groname(AclId grosysid)
|
|
|
|
{
|
1998-08-19 04:04:17 +02:00
|
|
|
HeapTuple tuple;
|
1997-09-08 04:41:22 +02:00
|
|
|
char *name = NULL;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-11-16 23:30:52 +01:00
|
|
|
tuple = SearchSysCache(GROSYSID,
|
|
|
|
ObjectIdGetDatum(grosysid),
|
|
|
|
0, 0, 0);
|
1998-08-19 04:04:17 +02:00
|
|
|
if (HeapTupleIsValid(tuple))
|
2000-11-16 23:30:52 +01:00
|
|
|
{
|
|
|
|
name = pstrdup(NameStr(((Form_pg_group) GETSTRUCT(tuple))->groname));
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
}
|
1998-09-01 05:29:17 +02:00
|
|
|
return name;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2001-06-05 21:34:56 +02:00
|
|
|
/*
|
|
|
|
* Is user a member of group?
|
|
|
|
*/
|
2000-08-01 00:39:17 +02:00
|
|
|
static bool
|
1996-07-09 08:22:35 +02:00
|
|
|
in_group(AclId uid, AclId gid)
|
|
|
|
{
|
2000-11-16 23:30:52 +01:00
|
|
|
bool result = false;
|
1998-08-19 04:04:17 +02:00
|
|
|
HeapTuple tuple;
|
2000-11-03 20:02:18 +01:00
|
|
|
Datum att;
|
|
|
|
bool isNull;
|
2001-06-05 21:34:56 +02:00
|
|
|
IdList *glist;
|
2000-11-03 20:02:18 +01:00
|
|
|
AclId *aidp;
|
2000-08-01 00:39:17 +02:00
|
|
|
int i,
|
1997-09-08 04:41:22 +02:00
|
|
|
num;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2000-11-16 23:30:52 +01:00
|
|
|
tuple = SearchSysCache(GROSYSID,
|
|
|
|
ObjectIdGetDatum(gid),
|
|
|
|
0, 0, 0);
|
2000-11-03 20:02:18 +01:00
|
|
|
if (HeapTupleIsValid(tuple))
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2000-11-03 20:02:18 +01:00
|
|
|
att = SysCacheGetAttr(GROSYSID,
|
|
|
|
tuple,
|
|
|
|
Anum_pg_group_grolist,
|
|
|
|
&isNull);
|
|
|
|
if (!isNull)
|
|
|
|
{
|
|
|
|
/* be sure the IdList is not toasted */
|
2001-06-05 21:34:56 +02:00
|
|
|
glist = DatumGetIdListP(att);
|
2000-11-03 20:02:18 +01:00
|
|
|
/* scan it */
|
2001-06-05 21:34:56 +02:00
|
|
|
num = IDLIST_NUM(glist);
|
|
|
|
aidp = IDLIST_DAT(glist);
|
2000-11-03 20:02:18 +01:00
|
|
|
for (i = 0; i < num; ++i)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2000-11-03 20:02:18 +01:00
|
|
|
if (aidp[i] == uid)
|
2000-11-16 23:30:52 +01:00
|
|
|
{
|
|
|
|
result = true;
|
|
|
|
break;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
2001-06-05 21:34:56 +02:00
|
|
|
/* if IdList was toasted, free detoasted copy */
|
|
|
|
if ((Pointer) glist != DatumGetPointer(att))
|
|
|
|
pfree(glist);
|
2000-11-03 20:02:18 +01:00
|
|
|
}
|
2000-11-16 23:30:52 +01:00
|
|
|
ReleaseSysCache(tuple);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
else
|
2002-03-06 07:10:59 +01:00
|
|
|
elog(WARNING, "in_group: group %u not found", gid);
|
2000-11-16 23:30:52 +01:00
|
|
|
return result;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2002-04-27 05:45:03 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
|
|
|
* aclcheck
|
2001-06-05 21:34:56 +02:00
|
|
|
*
|
|
|
|
* Returns ACLCHECK_OK if the 'id' of type 'idtype' has ACL entries in 'acl'
|
|
|
|
* to satisfy any one of the requirements of 'mode'. Returns an appropriate
|
|
|
|
* ACLCHECK_* error code otherwise.
|
|
|
|
*
|
|
|
|
* The ACL list is expected to be sorted in standard order.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2002-04-27 05:45:03 +02:00
|
|
|
static AclResult
|
2002-04-21 02:26:44 +02:00
|
|
|
aclcheck(Acl *acl, AclId id, uint32 idtype, AclMode mode)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1998-02-26 05:46:47 +01:00
|
|
|
AclItem *aip,
|
1997-09-08 04:41:22 +02:00
|
|
|
*aidat;
|
2000-11-03 20:02:18 +01:00
|
|
|
int i,
|
|
|
|
num;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-10-02 06:49:28 +02:00
|
|
|
/*
|
2001-03-22 05:01:46 +01:00
|
|
|
* If ACL is null, default to "OK" --- this should not happen, since
|
|
|
|
* caller should have inserted appropriate default
|
2000-10-02 06:49:28 +02:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
if (!acl)
|
2000-10-02 06:49:28 +02:00
|
|
|
{
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "aclcheck: null ACL, returning OK");
|
2000-10-02 06:49:28 +02:00
|
|
|
return ACLCHECK_OK;
|
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
num = ACL_NUM(acl);
|
|
|
|
aidat = ACL_DAT(acl);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We'll treat the empty ACL like that, too, although this is more
|
|
|
|
* like an error (i.e., you manually blew away your ACL array) -- the
|
2001-03-22 05:01:46 +01:00
|
|
|
* system never creates an empty ACL, since there must always be a
|
|
|
|
* "world" entry in the first slot.
|
1997-09-07 07:04:48 +02:00
|
|
|
*/
|
|
|
|
if (num < 1)
|
|
|
|
{
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "aclcheck: zero-length ACL, returning OK");
|
2001-06-05 21:34:56 +02:00
|
|
|
return ACLCHECK_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-10-25 07:50:21 +02:00
|
|
|
* "World" rights are applicable regardless of the passed-in ID, and
|
|
|
|
* since they're much the cheapest to check, check 'em first.
|
2001-06-05 21:34:56 +02:00
|
|
|
*/
|
2002-04-21 02:26:44 +02:00
|
|
|
if (ACLITEM_GET_IDTYPE(*aidat) != ACL_IDTYPE_WORLD)
|
2001-06-05 21:34:56 +02:00
|
|
|
elog(ERROR, "aclcheck: first entry in ACL is not 'world' entry");
|
2002-04-21 02:26:44 +02:00
|
|
|
if (aidat->ai_privs & mode)
|
2001-06-05 21:34:56 +02:00
|
|
|
{
|
|
|
|
#ifdef ACLDEBUG
|
2002-04-21 02:26:44 +02:00
|
|
|
elog(DEBUG1, "aclcheck: using world=%d", ACLITEM_GET_PRIVS(*aidat));
|
2001-06-05 21:34:56 +02:00
|
|
|
#endif
|
1997-09-07 07:04:48 +02:00
|
|
|
return ACLCHECK_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (idtype)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
case ACL_IDTYPE_UID:
|
2001-06-05 21:34:56 +02:00
|
|
|
/* See if permission is granted directly to user */
|
1997-09-08 04:41:22 +02:00
|
|
|
for (i = 1, aip = aidat + 1; /* skip world entry */
|
2002-04-21 02:26:44 +02:00
|
|
|
i < num && ACLITEM_GET_IDTYPE(*aip) == ACL_IDTYPE_UID;
|
1997-09-08 04:41:22 +02:00
|
|
|
++i, ++aip)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
if (aip->ai_id == id)
|
|
|
|
{
|
2001-05-27 11:59:30 +02:00
|
|
|
#ifdef ACLDEBUG
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "aclcheck: found user %u/%d",
|
2002-04-21 02:26:44 +02:00
|
|
|
aip->ai_id, ACLITEM_GET_PRIVS(*aip));
|
1996-07-09 08:22:35 +02:00
|
|
|
#endif
|
2002-04-21 02:26:44 +02:00
|
|
|
if (aip->ai_privs & mode)
|
2001-06-05 21:34:56 +02:00
|
|
|
return ACLCHECK_OK;
|
1997-09-08 04:41:22 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
2000-11-03 20:02:18 +01:00
|
|
|
/* See if he has the permission via any group */
|
|
|
|
for (;
|
2002-04-21 02:26:44 +02:00
|
|
|
i < num && ACLITEM_GET_IDTYPE(*aip) == ACL_IDTYPE_GID;
|
1997-09-08 04:41:22 +02:00
|
|
|
++i, ++aip)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2002-04-21 02:26:44 +02:00
|
|
|
if (aip->ai_privs & mode)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2000-11-03 20:02:18 +01:00
|
|
|
if (in_group(id, aip->ai_id))
|
1997-09-08 04:41:22 +02:00
|
|
|
{
|
2001-05-27 11:59:30 +02:00
|
|
|
#ifdef ACLDEBUG
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "aclcheck: found group %u/%d",
|
2002-04-21 02:26:44 +02:00
|
|
|
aip->ai_id, ACLITEM_GET_PRIVS(*aip));
|
1996-07-09 08:22:35 +02:00
|
|
|
#endif
|
2000-11-03 20:02:18 +01:00
|
|
|
return ACLCHECK_OK;
|
|
|
|
}
|
|
|
|
}
|
1997-09-08 04:41:22 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACL_IDTYPE_GID:
|
2000-11-03 20:02:18 +01:00
|
|
|
/* Look for this group ID */
|
2001-06-05 21:34:56 +02:00
|
|
|
for (i = 1, aip = aidat + 1; /* skip world entry */
|
2002-04-21 02:26:44 +02:00
|
|
|
i < num && ACLITEM_GET_IDTYPE(*aip) == ACL_IDTYPE_UID;
|
1997-09-08 04:41:22 +02:00
|
|
|
++i, ++aip)
|
2001-10-25 07:50:21 +02:00
|
|
|
/* skip UID entry */ ;
|
1997-09-08 04:41:22 +02:00
|
|
|
for (;
|
2002-04-21 02:26:44 +02:00
|
|
|
i < num && ACLITEM_GET_IDTYPE(*aip) == ACL_IDTYPE_GID;
|
1997-09-08 04:41:22 +02:00
|
|
|
++i, ++aip)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
if (aip->ai_id == id)
|
|
|
|
{
|
2001-05-27 11:59:30 +02:00
|
|
|
#ifdef ACLDEBUG
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "aclcheck: found group %u/%d",
|
2002-04-21 02:26:44 +02:00
|
|
|
aip->ai_id, ACLITEM_GET_PRIVS(*aip));
|
1996-07-09 08:22:35 +02:00
|
|
|
#endif
|
2002-04-21 02:26:44 +02:00
|
|
|
if (aip->ai_privs & mode)
|
2001-06-05 21:34:56 +02:00
|
|
|
return ACLCHECK_OK;
|
1997-09-08 04:41:22 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1997-09-08 04:41:22 +02:00
|
|
|
break;
|
|
|
|
case ACL_IDTYPE_WORLD:
|
2000-11-03 20:02:18 +01:00
|
|
|
/* Only check the world entry */
|
1997-09-08 04:41:22 +02:00
|
|
|
break;
|
|
|
|
default:
|
1998-01-05 17:40:20 +01:00
|
|
|
elog(ERROR, "aclcheck: bogus ACL id type: %d", idtype);
|
1997-09-08 04:41:22 +02:00
|
|
|
break;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-06-05 21:34:56 +02:00
|
|
|
/* If get here, he doesn't have the privilege nohow */
|
|
|
|
return ACLCHECK_NO_PRIV;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2002-03-22 00:27:25 +01:00
|
|
|
|
2002-04-27 05:45:03 +02:00
|
|
|
/*
|
|
|
|
* Standardized reporting of aclcheck permissions failures.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
aclcheck_error(AclResult errcode, const char *objectname)
|
|
|
|
{
|
|
|
|
switch (errcode)
|
|
|
|
{
|
|
|
|
case ACLCHECK_OK:
|
|
|
|
/* no error, so return to caller */
|
|
|
|
break;
|
|
|
|
case ACLCHECK_NO_PRIV:
|
|
|
|
elog(ERROR, "%s: permission denied", objectname);
|
|
|
|
break;
|
|
|
|
case ACLCHECK_NOT_OWNER:
|
|
|
|
elog(ERROR, "%s: must be owner", objectname);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "%s: unexpected AclResult %d",
|
|
|
|
objectname, (int) errcode);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-05 21:34:56 +02:00
|
|
|
/*
|
|
|
|
* Exported routine for checking a user's access privileges to a table
|
|
|
|
*/
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult
|
2002-03-22 00:27:25 +01:00
|
|
|
pg_class_aclcheck(Oid table_oid, Oid userid, AclMode mode)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult result;
|
2002-03-22 00:27:25 +01:00
|
|
|
bool usesuper,
|
|
|
|
usecatupd;
|
2000-10-02 06:49:28 +02:00
|
|
|
HeapTuple tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *acl;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2001-06-05 21:34:56 +02:00
|
|
|
/*
|
2002-04-11 22:00:18 +02:00
|
|
|
* Validate userid, find out if he is superuser, also get usecatupd
|
2001-06-05 21:34:56 +02:00
|
|
|
*/
|
2000-11-16 23:30:52 +01:00
|
|
|
tuple = SearchSysCache(SHADOWSYSID,
|
|
|
|
ObjectIdGetDatum(userid),
|
|
|
|
0, 0, 0);
|
1998-08-19 04:04:17 +02:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(ERROR, "pg_class_aclcheck: invalid user id %u", userid);
|
2000-09-06 16:15:31 +02:00
|
|
|
|
2002-03-22 00:27:25 +01:00
|
|
|
usecatupd = ((Form_pg_shadow) GETSTRUCT(tuple))->usecatupd;
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
2002-04-11 07:32:03 +02:00
|
|
|
usesuper = superuser_arg(userid);
|
|
|
|
|
2002-03-22 00:27:25 +01:00
|
|
|
/*
|
|
|
|
* Now get the relation's tuple from pg_class
|
|
|
|
*/
|
|
|
|
tuple = SearchSysCache(RELOID,
|
|
|
|
ObjectIdGetDatum(table_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_class_aclcheck: relation %u not found", table_oid);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Deny anyone permission to update a system catalog unless
|
1998-02-26 05:46:47 +01:00
|
|
|
* pg_shadow.usecatupd is set. (This is to let superusers protect
|
1997-09-07 07:04:48 +02:00
|
|
|
* themselves from themselves.)
|
|
|
|
*/
|
2001-06-05 21:34:56 +02:00
|
|
|
if ((mode & (ACL_INSERT | ACL_UPDATE | ACL_DELETE)) &&
|
2002-04-12 22:38:31 +02:00
|
|
|
!allowSystemTableMods &&
|
|
|
|
IsSystemClass((Form_pg_class) GETSTRUCT(tuple)) &&
|
2002-03-22 00:27:25 +01:00
|
|
|
!usecatupd)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2001-06-05 21:34:56 +02:00
|
|
|
#ifdef ACLDEBUG
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "pg_class_aclcheck: catalog update: permission denied");
|
2001-06-05 21:34:56 +02:00
|
|
|
#endif
|
2000-11-16 23:30:52 +01:00
|
|
|
ReleaseSysCache(tuple);
|
1997-09-07 07:04:48 +02:00
|
|
|
return ACLCHECK_NO_PRIV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Otherwise, superusers bypass all permission-checking.
|
|
|
|
*/
|
2002-03-22 00:27:25 +01:00
|
|
|
if (usesuper)
|
1997-09-07 07:04:48 +02:00
|
|
|
{
|
2001-05-27 11:59:30 +02:00
|
|
|
#ifdef ACLDEBUG
|
2002-03-22 00:27:25 +01:00
|
|
|
elog(DEBUG1, "pg_class_aclcheck: %u is superuser", userid);
|
1996-07-09 08:22:35 +02:00
|
|
|
#endif
|
2000-11-16 23:30:52 +01:00
|
|
|
ReleaseSysCache(tuple);
|
1997-09-07 07:04:48 +02:00
|
|
|
return ACLCHECK_OK;
|
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2000-10-02 06:49:28 +02:00
|
|
|
/*
|
|
|
|
* Normal case: get the relation's ACL from pg_class
|
|
|
|
*/
|
2002-03-22 00:27:25 +01:00
|
|
|
aclDatum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relacl,
|
2000-10-02 06:49:28 +02:00
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
|
|
|
{
|
|
|
|
/* No ACL, so build default ACL for rel */
|
2000-08-01 00:39:17 +02:00
|
|
|
AclId ownerId;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-08-01 00:39:17 +02:00
|
|
|
ownerId = ((Form_pg_class) GETSTRUCT(tuple))->relowner;
|
2002-04-21 02:26:44 +02:00
|
|
|
acl = acldefault(ACL_OBJECT_RELATION, ownerId);
|
2001-06-05 21:34:56 +02:00
|
|
|
aclDatum = (Datum) 0;
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
2000-10-02 06:49:28 +02:00
|
|
|
else
|
1999-09-18 21:08:25 +02:00
|
|
|
{
|
2001-06-05 21:34:56 +02:00
|
|
|
/* detoast rel's ACL if necessary */
|
|
|
|
acl = DatumGetAclP(aclDatum);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
2000-10-02 06:49:28 +02:00
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
result = aclcheck(acl, userid, ACL_IDTYPE_UID, mode);
|
2000-11-16 23:30:52 +01:00
|
|
|
|
2001-06-05 21:34:56 +02:00
|
|
|
/* if we have a detoasted copy, free it */
|
|
|
|
if (acl && (Pointer) acl != DatumGetPointer(aclDatum))
|
1997-09-07 07:04:48 +02:00
|
|
|
pfree(acl);
|
2001-06-05 21:34:56 +02:00
|
|
|
|
2000-11-16 23:30:52 +01:00
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return result;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
/*
|
|
|
|
* Exported routine for checking a user's access privileges to a database
|
|
|
|
*/
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult
|
2002-04-21 02:26:44 +02:00
|
|
|
pg_database_aclcheck(Oid db_oid, Oid userid, AclMode mode)
|
|
|
|
{
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult result;
|
2002-04-21 02:26:44 +02:00
|
|
|
Relation pg_database;
|
|
|
|
ScanKeyData entry[1];
|
|
|
|
HeapScanDesc scan;
|
|
|
|
HeapTuple tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *acl;
|
|
|
|
|
|
|
|
/* Superusers bypass all permission checking. */
|
|
|
|
if (superuser_arg(userid))
|
|
|
|
return ACLCHECK_OK;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the database's ACL from pg_database
|
|
|
|
*
|
|
|
|
* There's no syscache for pg_database, so must look the hard way
|
|
|
|
*/
|
|
|
|
pg_database = heap_openr(DatabaseRelationName, AccessShareLock);
|
|
|
|
ScanKeyEntryInitialize(&entry[0], 0x0,
|
|
|
|
ObjectIdAttributeNumber, F_OIDEQ,
|
|
|
|
ObjectIdGetDatum(db_oid));
|
2002-05-21 01:51:44 +02:00
|
|
|
scan = heap_beginscan(pg_database, SnapshotNow, 1, entry);
|
|
|
|
tuple = heap_getnext(scan, ForwardScanDirection);
|
2002-04-21 02:26:44 +02:00
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_database_aclcheck: database %u not found", db_oid);
|
|
|
|
|
|
|
|
aclDatum = heap_getattr(tuple, Anum_pg_database_datacl,
|
|
|
|
RelationGetDescr(pg_database), &isNull);
|
|
|
|
|
|
|
|
if (isNull)
|
|
|
|
{
|
|
|
|
/* No ACL, so build default ACL */
|
|
|
|
AclId ownerId;
|
|
|
|
|
|
|
|
ownerId = ((Form_pg_database) GETSTRUCT(tuple))->datdba;
|
|
|
|
acl = acldefault(ACL_OBJECT_DATABASE, ownerId);
|
|
|
|
aclDatum = (Datum) 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* detoast ACL if necessary */
|
|
|
|
acl = DatumGetAclP(aclDatum);
|
|
|
|
}
|
|
|
|
|
|
|
|
result = aclcheck(acl, userid, ACL_IDTYPE_UID, mode);
|
|
|
|
|
|
|
|
/* if we have a detoasted copy, free it */
|
|
|
|
if (acl && (Pointer) acl != DatumGetPointer(aclDatum))
|
|
|
|
pfree(acl);
|
|
|
|
|
|
|
|
heap_endscan(scan);
|
|
|
|
heap_close(pg_database, AccessShareLock);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
/*
|
|
|
|
* Exported routine for checking a user's access privileges to a function
|
|
|
|
*/
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult
|
2002-04-21 02:26:44 +02:00
|
|
|
pg_proc_aclcheck(Oid proc_oid, Oid userid, AclMode mode)
|
2002-02-19 00:11:58 +01:00
|
|
|
{
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult result;
|
2002-02-19 00:11:58 +01:00
|
|
|
HeapTuple tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *acl;
|
|
|
|
|
2002-03-22 00:27:25 +01:00
|
|
|
/* Superusers bypass all permission checking. */
|
2002-02-19 00:11:58 +01:00
|
|
|
if (superuser_arg(userid))
|
|
|
|
return ACLCHECK_OK;
|
|
|
|
|
|
|
|
/*
|
2002-03-22 00:27:25 +01:00
|
|
|
* Get the function's ACL from pg_proc
|
2002-02-19 00:11:58 +01:00
|
|
|
*/
|
|
|
|
tuple = SearchSysCache(PROCOID,
|
|
|
|
ObjectIdGetDatum(proc_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_proc_aclcheck: function %u not found", proc_oid);
|
|
|
|
|
|
|
|
aclDatum = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_proacl,
|
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
|
|
|
{
|
|
|
|
/* No ACL, so build default ACL */
|
|
|
|
AclId ownerId;
|
|
|
|
|
|
|
|
ownerId = ((Form_pg_proc) GETSTRUCT(tuple))->proowner;
|
2002-04-21 02:26:44 +02:00
|
|
|
acl = acldefault(ACL_OBJECT_FUNCTION, ownerId);
|
2002-02-19 00:11:58 +01:00
|
|
|
aclDatum = (Datum) 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* detoast ACL if necessary */
|
|
|
|
acl = DatumGetAclP(aclDatum);
|
|
|
|
}
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
result = aclcheck(acl, userid, ACL_IDTYPE_UID, mode);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
|
|
|
/* if we have a detoasted copy, free it */
|
|
|
|
if (acl && (Pointer) acl != DatumGetPointer(aclDatum))
|
|
|
|
pfree(acl);
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Exported routine for checking a user's access privileges to a language
|
|
|
|
*/
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult
|
2002-04-21 02:26:44 +02:00
|
|
|
pg_language_aclcheck(Oid lang_oid, Oid userid, AclMode mode)
|
2002-02-19 00:11:58 +01:00
|
|
|
{
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult result;
|
2002-02-19 00:11:58 +01:00
|
|
|
HeapTuple tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *acl;
|
|
|
|
|
2002-03-22 00:27:25 +01:00
|
|
|
/* Superusers bypass all permission checking. */
|
2002-02-19 00:11:58 +01:00
|
|
|
if (superuser_arg(userid))
|
|
|
|
return ACLCHECK_OK;
|
|
|
|
|
|
|
|
/*
|
2002-03-22 00:27:25 +01:00
|
|
|
* Get the function's ACL from pg_language
|
2002-02-19 00:11:58 +01:00
|
|
|
*/
|
|
|
|
tuple = SearchSysCache(LANGOID,
|
|
|
|
ObjectIdGetDatum(lang_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_language_aclcheck: language %u not found", lang_oid);
|
|
|
|
|
|
|
|
aclDatum = SysCacheGetAttr(LANGOID, tuple, Anum_pg_language_lanacl,
|
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
|
|
|
{
|
|
|
|
/* No ACL, so build default ACL */
|
2002-04-21 02:26:44 +02:00
|
|
|
acl = acldefault(ACL_OBJECT_LANGUAGE, InvalidOid);
|
2002-02-19 00:11:58 +01:00
|
|
|
aclDatum = (Datum) 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* detoast ACL if necessary */
|
|
|
|
acl = DatumGetAclP(aclDatum);
|
|
|
|
}
|
|
|
|
|
2002-04-21 02:26:44 +02:00
|
|
|
result = aclcheck(acl, userid, ACL_IDTYPE_UID, mode);
|
|
|
|
|
|
|
|
/* if we have a detoasted copy, free it */
|
|
|
|
if (acl && (Pointer) acl != DatumGetPointer(aclDatum))
|
|
|
|
pfree(acl);
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Exported routine for checking a user's access privileges to a namespace
|
|
|
|
*/
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult
|
2002-04-21 02:26:44 +02:00
|
|
|
pg_namespace_aclcheck(Oid nsp_oid, Oid userid, AclMode mode)
|
|
|
|
{
|
2002-04-27 05:45:03 +02:00
|
|
|
AclResult result;
|
2002-04-21 02:26:44 +02:00
|
|
|
HeapTuple tuple;
|
|
|
|
Datum aclDatum;
|
|
|
|
bool isNull;
|
|
|
|
Acl *acl;
|
|
|
|
|
|
|
|
/* Superusers bypass all permission checking. */
|
|
|
|
if (superuser_arg(userid))
|
|
|
|
return ACLCHECK_OK;
|
|
|
|
|
2002-02-19 00:11:58 +01:00
|
|
|
/*
|
2002-04-21 02:26:44 +02:00
|
|
|
* Get the function's ACL from pg_namespace
|
2002-02-19 00:11:58 +01:00
|
|
|
*/
|
2002-04-21 02:26:44 +02:00
|
|
|
tuple = SearchSysCache(NAMESPACEOID,
|
|
|
|
ObjectIdGetDatum(nsp_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_namespace_aclcheck: namespace %u not found", nsp_oid);
|
|
|
|
|
|
|
|
aclDatum = SysCacheGetAttr(NAMESPACEOID, tuple, Anum_pg_namespace_nspacl,
|
|
|
|
&isNull);
|
|
|
|
if (isNull)
|
|
|
|
{
|
|
|
|
/* No ACL, so build default ACL */
|
|
|
|
AclId ownerId;
|
|
|
|
|
|
|
|
ownerId = ((Form_pg_namespace) GETSTRUCT(tuple))->nspowner;
|
|
|
|
acl = acldefault(ACL_OBJECT_NAMESPACE, ownerId);
|
|
|
|
aclDatum = (Datum) 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* detoast ACL if necessary */
|
|
|
|
acl = DatumGetAclP(aclDatum);
|
|
|
|
}
|
|
|
|
|
|
|
|
result = aclcheck(acl, userid, ACL_IDTYPE_UID, mode);
|
2002-02-19 00:11:58 +01:00
|
|
|
|
|
|
|
/* if we have a detoasted copy, free it */
|
|
|
|
if (acl && (Pointer) acl != DatumGetPointer(aclDatum))
|
|
|
|
pfree(acl);
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2002-03-22 00:27:25 +01:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ownership check for a relation (specified by OID).
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
pg_class_ownercheck(Oid class_oid, Oid userid)
|
|
|
|
{
|
|
|
|
HeapTuple tuple;
|
|
|
|
AclId owner_id;
|
|
|
|
|
|
|
|
/* Superusers bypass all permission checking. */
|
|
|
|
if (superuser_arg(userid))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
tuple = SearchSysCache(RELOID,
|
|
|
|
ObjectIdGetDatum(class_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_class_ownercheck: relation %u not found", class_oid);
|
|
|
|
|
|
|
|
owner_id = ((Form_pg_class) GETSTRUCT(tuple))->relowner;
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return userid == owner_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ownership check for a type (specified by OID).
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
pg_type_ownercheck(Oid type_oid, Oid userid)
|
|
|
|
{
|
|
|
|
HeapTuple tuple;
|
|
|
|
AclId owner_id;
|
|
|
|
|
|
|
|
/* Superusers bypass all permission checking. */
|
|
|
|
if (superuser_arg(userid))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
tuple = SearchSysCache(TYPEOID,
|
|
|
|
ObjectIdGetDatum(type_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_type_ownercheck: type %u not found", type_oid);
|
|
|
|
|
|
|
|
owner_id = ((Form_pg_type) GETSTRUCT(tuple))->typowner;
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return userid == owner_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ownership check for an operator (specified by OID).
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
pg_oper_ownercheck(Oid oper_oid, Oid userid)
|
|
|
|
{
|
|
|
|
HeapTuple tuple;
|
|
|
|
AclId owner_id;
|
|
|
|
|
|
|
|
/* Superusers bypass all permission checking. */
|
|
|
|
if (superuser_arg(userid))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
tuple = SearchSysCache(OPEROID,
|
|
|
|
ObjectIdGetDatum(oper_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_oper_ownercheck: operator %u not found", oper_oid);
|
|
|
|
|
|
|
|
owner_id = ((Form_pg_operator) GETSTRUCT(tuple))->oprowner;
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return userid == owner_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ownership check for a function (specified by OID).
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
pg_proc_ownercheck(Oid proc_oid, Oid userid)
|
|
|
|
{
|
|
|
|
HeapTuple tuple;
|
|
|
|
AclId owner_id;
|
|
|
|
|
|
|
|
/* Superusers bypass all permission checking. */
|
|
|
|
if (superuser_arg(userid))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
tuple = SearchSysCache(PROCOID,
|
|
|
|
ObjectIdGetDatum(proc_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_proc_ownercheck: function %u not found", proc_oid);
|
|
|
|
|
|
|
|
owner_id = ((Form_pg_proc) GETSTRUCT(tuple))->proowner;
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return userid == owner_id;
|
|
|
|
}
|
2002-04-21 02:26:44 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Ownership check for a namespace (specified by OID).
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
pg_namespace_ownercheck(Oid nsp_oid, Oid userid)
|
|
|
|
{
|
|
|
|
HeapTuple tuple;
|
|
|
|
AclId owner_id;
|
|
|
|
|
|
|
|
/* Superusers bypass all permission checking. */
|
|
|
|
if (superuser_arg(userid))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
tuple = SearchSysCache(NAMESPACEOID,
|
|
|
|
ObjectIdGetDatum(nsp_oid),
|
|
|
|
0, 0, 0);
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "pg_namespace_ownercheck: namespace %u not found",
|
|
|
|
nsp_oid);
|
|
|
|
|
|
|
|
owner_id = ((Form_pg_namespace) GETSTRUCT(tuple))->nspowner;
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
|
|
|
|
return userid == owner_id;
|
|
|
|
}
|