PostgreSQL Source Code  git master
acl.h File Reference
#include "access/htup.h"
#include "nodes/parsenodes.h"
#include "parser/parse_node.h"
#include "utils/snapshot.h"
Include dependency graph for acl.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  AclItem
 

Macros

#define ACL_ID_PUBLIC   0 /* placeholder for id in a PUBLIC acl item */
 
#define ACLITEM_GET_PRIVS(item)   ((item).ai_privs & 0xFFFFFFFF)
 
#define ACLITEM_GET_GOPTIONS(item)   (((item).ai_privs >> 32) & 0xFFFFFFFF)
 
#define ACLITEM_GET_RIGHTS(item)   ((item).ai_privs)
 
#define ACL_GRANT_OPTION_FOR(privs)   (((AclMode) (privs) & 0xFFFFFFFF) << 32)
 
#define ACL_OPTION_TO_PRIVS(privs)   (((AclMode) (privs) >> 32) & 0xFFFFFFFF)
 
#define ACLITEM_SET_PRIVS(item, privs)
 
#define ACLITEM_SET_GOPTIONS(item, goptions)
 
#define ACLITEM_SET_RIGHTS(item, rights)    ((item).ai_privs = (AclMode) (rights))
 
#define ACLITEM_SET_PRIVS_GOPTIONS(item, privs, goptions)
 
#define ACLITEM_ALL_PRIV_BITS   ((AclMode) 0xFFFFFFFF)
 
#define ACLITEM_ALL_GOPTION_BITS   ((AclMode) 0xFFFFFFFF << 32)
 
#define ACL_NUM(ACL)   (ARR_DIMS(ACL)[0])
 
#define ACL_DAT(ACL)   ((AclItem *) ARR_DATA_PTR(ACL))
 
#define ACL_N_SIZE(N)   (ARR_OVERHEAD_NONULLS(1) + ((N) * sizeof(AclItem)))
 
#define ACL_SIZE(ACL)   ARR_SIZE(ACL)
 
#define DatumGetAclItemP(X)   ((AclItem *) DatumGetPointer(X))
 
#define PG_GETARG_ACLITEM_P(n)   DatumGetAclItemP(PG_GETARG_DATUM(n))
 
#define PG_RETURN_ACLITEM_P(x)   PG_RETURN_POINTER(x)
 
#define DatumGetAclP(X)   ((Acl *) PG_DETOAST_DATUM(X))
 
#define DatumGetAclPCopy(X)   ((Acl *) PG_DETOAST_DATUM_COPY(X))
 
#define PG_GETARG_ACL_P(n)   DatumGetAclP(PG_GETARG_DATUM(n))
 
#define PG_GETARG_ACL_P_COPY(n)   DatumGetAclPCopy(PG_GETARG_DATUM(n))
 
#define PG_RETURN_ACL_P(x)   PG_RETURN_POINTER(x)
 
#define ACL_MODECHG_ADD   1
 
#define ACL_MODECHG_DEL   2
 
#define ACL_MODECHG_EQL   3
 
#define ACL_INSERT_CHR   'a' /* formerly known as "append" */
 
#define ACL_SELECT_CHR   'r' /* formerly known as "read" */
 
#define ACL_UPDATE_CHR   'w' /* formerly known as "write" */
 
#define ACL_DELETE_CHR   'd'
 
#define ACL_TRUNCATE_CHR   'D' /* super-delete, as it were */
 
#define ACL_REFERENCES_CHR   'x'
 
#define ACL_TRIGGER_CHR   't'
 
#define ACL_EXECUTE_CHR   'X'
 
#define ACL_USAGE_CHR   'U'
 
#define ACL_CREATE_CHR   'C'
 
#define ACL_CREATE_TEMP_CHR   'T'
 
#define ACL_CONNECT_CHR   'c'
 
#define ACL_SET_CHR   's'
 
#define ACL_ALTER_SYSTEM_CHR   'A'
 
#define ACL_MAINTAIN_CHR   'm'
 
#define ACL_ALL_RIGHTS_STR   "arwdDxtXUCTcsAm"
 
#define ACL_ALL_RIGHTS_COLUMN   (ACL_INSERT|ACL_SELECT|ACL_UPDATE|ACL_REFERENCES)
 
#define ACL_ALL_RIGHTS_RELATION   (ACL_INSERT|ACL_SELECT|ACL_UPDATE|ACL_DELETE|ACL_TRUNCATE|ACL_REFERENCES|ACL_TRIGGER|ACL_MAINTAIN)
 
#define ACL_ALL_RIGHTS_SEQUENCE   (ACL_USAGE|ACL_SELECT|ACL_UPDATE)
 
#define ACL_ALL_RIGHTS_DATABASE   (ACL_CREATE|ACL_CREATE_TEMP|ACL_CONNECT)
 
#define ACL_ALL_RIGHTS_FDW   (ACL_USAGE)
 
#define ACL_ALL_RIGHTS_FOREIGN_SERVER   (ACL_USAGE)
 
#define ACL_ALL_RIGHTS_FUNCTION   (ACL_EXECUTE)
 
#define ACL_ALL_RIGHTS_LANGUAGE   (ACL_USAGE)
 
#define ACL_ALL_RIGHTS_LARGEOBJECT   (ACL_SELECT|ACL_UPDATE)
 
#define ACL_ALL_RIGHTS_PARAMETER_ACL   (ACL_SET|ACL_ALTER_SYSTEM)
 
#define ACL_ALL_RIGHTS_SCHEMA   (ACL_USAGE|ACL_CREATE)
 
#define ACL_ALL_RIGHTS_TABLESPACE   (ACL_CREATE)
 
#define ACL_ALL_RIGHTS_TYPE   (ACL_USAGE)
 

Typedefs

typedef struct AclItem AclItem
 
typedef struct ArrayType Acl
 

Enumerations

enum  AclMaskHow { ACLMASK_ALL , ACLMASK_ANY }
 
enum  AclResult { ACLCHECK_OK = 0 , ACLCHECK_NO_PRIV , ACLCHECK_NOT_OWNER }
 

Functions

Aclacldefault (ObjectType objtype, Oid ownerId)
 
Aclget_user_default_acl (ObjectType objtype, Oid ownerId, Oid nsp_oid)
 
void recordDependencyOnNewAcl (Oid classId, Oid objectId, int32 objsubId, Oid ownerId, Acl *acl)
 
Aclaclupdate (const Acl *old_acl, const AclItem *mod_aip, int modechg, Oid ownerId, DropBehavior behavior)
 
Aclaclnewowner (const Acl *old_acl, Oid oldOwnerId, Oid newOwnerId)
 
Aclmake_empty_acl (void)
 
Aclaclcopy (const Acl *orig_acl)
 
Aclaclconcat (const Acl *left_acl, const Acl *right_acl)
 
Aclaclmerge (const Acl *left_acl, const Acl *right_acl, Oid ownerId)
 
void aclitemsort (Acl *acl)
 
bool aclequal (const Acl *left_acl, const Acl *right_acl)
 
AclMode aclmask (const Acl *acl, Oid roleid, Oid ownerId, AclMode mask, AclMaskHow how)
 
int aclmembers (const Acl *acl, Oid **roleids)
 
bool has_privs_of_role (Oid member, Oid role)
 
bool member_can_set_role (Oid member, Oid role)
 
void check_can_set_role (Oid member, Oid role)
 
bool is_member_of_role (Oid member, Oid role)
 
bool is_member_of_role_nosuper (Oid member, Oid role)
 
bool is_admin_of_role (Oid member, Oid role)
 
Oid select_best_admin (Oid member, Oid role)
 
Oid get_role_oid (const char *rolname, bool missing_ok)
 
Oid get_role_oid_or_public (const char *rolname)
 
Oid get_rolespec_oid (const RoleSpec *role, bool missing_ok)
 
void check_rolespec_name (const RoleSpec *role, const char *detail_msg)
 
HeapTuple get_rolespec_tuple (const RoleSpec *role)
 
char * get_rolespec_name (const RoleSpec *role)
 
void select_best_grantor (Oid roleId, AclMode privileges, const Acl *acl, Oid ownerId, Oid *grantorId, AclMode *grantOptions)
 
void initialize_acl (void)
 
void ExecuteGrantStmt (GrantStmt *stmt)
 
void ExecAlterDefaultPrivilegesStmt (ParseState *pstate, AlterDefaultPrivilegesStmt *stmt)
 
void RemoveRoleFromObjectACL (Oid roleid, Oid classid, Oid objid)
 
AclMode pg_class_aclmask (Oid table_oid, Oid roleid, AclMode mask, AclMaskHow how)
 
AclResult object_aclcheck (Oid classid, Oid objectid, Oid roleid, AclMode mode)
 
AclResult object_aclcheck_ext (Oid classid, Oid objectid, Oid roleid, AclMode mode, bool *is_missing)
 
AclResult pg_attribute_aclcheck (Oid table_oid, AttrNumber attnum, Oid roleid, AclMode mode)
 
AclResult pg_attribute_aclcheck_ext (Oid table_oid, AttrNumber attnum, Oid roleid, AclMode mode, bool *is_missing)
 
AclResult pg_attribute_aclcheck_all (Oid table_oid, Oid roleid, AclMode mode, AclMaskHow how)
 
AclResult pg_attribute_aclcheck_all_ext (Oid table_oid, Oid roleid, AclMode mode, AclMaskHow how, bool *is_missing)
 
AclResult pg_class_aclcheck (Oid table_oid, Oid roleid, AclMode mode)
 
AclResult pg_class_aclcheck_ext (Oid table_oid, Oid roleid, AclMode mode, bool *is_missing)
 
AclResult pg_parameter_aclcheck (const char *name, Oid roleid, AclMode mode)
 
AclResult pg_largeobject_aclcheck_snapshot (Oid lobj_oid, Oid roleid, AclMode mode, Snapshot snapshot)
 
void aclcheck_error (AclResult aclerr, ObjectType objtype, const char *objectname)
 
void aclcheck_error_col (AclResult aclerr, ObjectType objtype, const char *objectname, const char *colname)
 
void aclcheck_error_type (AclResult aclerr, Oid typeOid)
 
void recordExtObjInitPriv (Oid objoid, Oid classoid)
 
void removeExtObjInitPriv (Oid objoid, Oid classoid)
 
bool object_ownercheck (Oid classid, Oid objectid, Oid roleid)
 
bool has_createrole_privilege (Oid roleid)
 
bool has_bypassrls_privilege (Oid roleid)
 

Macro Definition Documentation

◆ ACL_ALL_RIGHTS_COLUMN

#define ACL_ALL_RIGHTS_COLUMN   (ACL_INSERT|ACL_SELECT|ACL_UPDATE|ACL_REFERENCES)

Definition at line 159 of file acl.h.

◆ ACL_ALL_RIGHTS_DATABASE

#define ACL_ALL_RIGHTS_DATABASE   (ACL_CREATE|ACL_CREATE_TEMP|ACL_CONNECT)

Definition at line 162 of file acl.h.

◆ ACL_ALL_RIGHTS_FDW

#define ACL_ALL_RIGHTS_FDW   (ACL_USAGE)

Definition at line 163 of file acl.h.

◆ ACL_ALL_RIGHTS_FOREIGN_SERVER

#define ACL_ALL_RIGHTS_FOREIGN_SERVER   (ACL_USAGE)

Definition at line 164 of file acl.h.

◆ ACL_ALL_RIGHTS_FUNCTION

#define ACL_ALL_RIGHTS_FUNCTION   (ACL_EXECUTE)

Definition at line 165 of file acl.h.

◆ ACL_ALL_RIGHTS_LANGUAGE

#define ACL_ALL_RIGHTS_LANGUAGE   (ACL_USAGE)

Definition at line 166 of file acl.h.

◆ ACL_ALL_RIGHTS_LARGEOBJECT

#define ACL_ALL_RIGHTS_LARGEOBJECT   (ACL_SELECT|ACL_UPDATE)

Definition at line 167 of file acl.h.

◆ ACL_ALL_RIGHTS_PARAMETER_ACL

#define ACL_ALL_RIGHTS_PARAMETER_ACL   (ACL_SET|ACL_ALTER_SYSTEM)

Definition at line 168 of file acl.h.

◆ ACL_ALL_RIGHTS_RELATION

Definition at line 160 of file acl.h.

◆ ACL_ALL_RIGHTS_SCHEMA

#define ACL_ALL_RIGHTS_SCHEMA   (ACL_USAGE|ACL_CREATE)

Definition at line 169 of file acl.h.

◆ ACL_ALL_RIGHTS_SEQUENCE

#define ACL_ALL_RIGHTS_SEQUENCE   (ACL_USAGE|ACL_SELECT|ACL_UPDATE)

Definition at line 161 of file acl.h.

◆ ACL_ALL_RIGHTS_STR

#define ACL_ALL_RIGHTS_STR   "arwdDxtXUCTcsAm"

Definition at line 154 of file acl.h.

◆ ACL_ALL_RIGHTS_TABLESPACE

#define ACL_ALL_RIGHTS_TABLESPACE   (ACL_CREATE)

Definition at line 170 of file acl.h.

◆ ACL_ALL_RIGHTS_TYPE

#define ACL_ALL_RIGHTS_TYPE   (ACL_USAGE)

Definition at line 171 of file acl.h.

◆ ACL_ALTER_SYSTEM_CHR

#define ACL_ALTER_SYSTEM_CHR   'A'

Definition at line 150 of file acl.h.

◆ ACL_CONNECT_CHR

#define ACL_CONNECT_CHR   'c'

Definition at line 148 of file acl.h.

◆ ACL_CREATE_CHR

#define ACL_CREATE_CHR   'C'

Definition at line 146 of file acl.h.

◆ ACL_CREATE_TEMP_CHR

#define ACL_CREATE_TEMP_CHR   'T'

Definition at line 147 of file acl.h.

◆ ACL_DAT

#define ACL_DAT (   ACL)    ((AclItem *) ARR_DATA_PTR(ACL))

Definition at line 109 of file acl.h.

◆ ACL_DELETE_CHR

#define ACL_DELETE_CHR   'd'

Definition at line 140 of file acl.h.

◆ ACL_EXECUTE_CHR

#define ACL_EXECUTE_CHR   'X'

Definition at line 144 of file acl.h.

◆ ACL_GRANT_OPTION_FOR

#define ACL_GRANT_OPTION_FOR (   privs)    (((AclMode) (privs) & 0xFFFFFFFF) << 32)

Definition at line 70 of file acl.h.

◆ ACL_ID_PUBLIC

#define ACL_ID_PUBLIC   0 /* placeholder for id in a PUBLIC acl item */

Definition at line 46 of file acl.h.

◆ ACL_INSERT_CHR

#define ACL_INSERT_CHR   'a' /* formerly known as "append" */

Definition at line 137 of file acl.h.

◆ ACL_MAINTAIN_CHR

#define ACL_MAINTAIN_CHR   'm'

Definition at line 151 of file acl.h.

◆ ACL_MODECHG_ADD

#define ACL_MODECHG_ADD   1

Definition at line 129 of file acl.h.

◆ ACL_MODECHG_DEL

#define ACL_MODECHG_DEL   2

Definition at line 130 of file acl.h.

◆ ACL_MODECHG_EQL

#define ACL_MODECHG_EQL   3

Definition at line 131 of file acl.h.

◆ ACL_N_SIZE

#define ACL_N_SIZE (   N)    (ARR_OVERHEAD_NONULLS(1) + ((N) * sizeof(AclItem)))

Definition at line 110 of file acl.h.

◆ ACL_NUM

#define ACL_NUM (   ACL)    (ARR_DIMS(ACL)[0])

Definition at line 108 of file acl.h.

◆ ACL_OPTION_TO_PRIVS

#define ACL_OPTION_TO_PRIVS (   privs)    (((AclMode) (privs) >> 32) & 0xFFFFFFFF)

Definition at line 71 of file acl.h.

◆ ACL_REFERENCES_CHR

#define ACL_REFERENCES_CHR   'x'

Definition at line 142 of file acl.h.

◆ ACL_SELECT_CHR

#define ACL_SELECT_CHR   'r' /* formerly known as "read" */

Definition at line 138 of file acl.h.

◆ ACL_SET_CHR

#define ACL_SET_CHR   's'

Definition at line 149 of file acl.h.

◆ ACL_SIZE

#define ACL_SIZE (   ACL)    ARR_SIZE(ACL)

Definition at line 111 of file acl.h.

◆ ACL_TRIGGER_CHR

#define ACL_TRIGGER_CHR   't'

Definition at line 143 of file acl.h.

◆ ACL_TRUNCATE_CHR

#define ACL_TRUNCATE_CHR   'D' /* super-delete, as it were */

Definition at line 141 of file acl.h.

◆ ACL_UPDATE_CHR

#define ACL_UPDATE_CHR   'w' /* formerly known as "write" */

Definition at line 139 of file acl.h.

◆ ACL_USAGE_CHR

#define ACL_USAGE_CHR   'U'

Definition at line 145 of file acl.h.

◆ ACLITEM_ALL_GOPTION_BITS

#define ACLITEM_ALL_GOPTION_BITS   ((AclMode) 0xFFFFFFFF << 32)

Definition at line 88 of file acl.h.

◆ ACLITEM_ALL_PRIV_BITS

#define ACLITEM_ALL_PRIV_BITS   ((AclMode) 0xFFFFFFFF)

Definition at line 87 of file acl.h.

◆ ACLITEM_GET_GOPTIONS

#define ACLITEM_GET_GOPTIONS (   item)    (((item).ai_privs >> 32) & 0xFFFFFFFF)

Definition at line 67 of file acl.h.

◆ ACLITEM_GET_PRIVS

#define ACLITEM_GET_PRIVS (   item)    ((item).ai_privs & 0xFFFFFFFF)

Definition at line 66 of file acl.h.

◆ ACLITEM_GET_RIGHTS

#define ACLITEM_GET_RIGHTS (   item)    ((item).ai_privs)

Definition at line 68 of file acl.h.

◆ ACLITEM_SET_GOPTIONS

#define ACLITEM_SET_GOPTIONS (   item,
  goptions 
)
Value:
((item).ai_privs = ((item).ai_privs & ~(((AclMode) 0xFFFFFFFF) << 32)) | \
(((AclMode) (goptions) & 0xFFFFFFFF) << 32))
uint64 AclMode
Definition: parsenodes.h:74

Definition at line 76 of file acl.h.

◆ ACLITEM_SET_PRIVS

#define ACLITEM_SET_PRIVS (   item,
  privs 
)
Value:
((item).ai_privs = ((item).ai_privs & ~((AclMode) 0xFFFFFFFF)) | \
((AclMode) (privs) & 0xFFFFFFFF))

Definition at line 73 of file acl.h.

◆ ACLITEM_SET_PRIVS_GOPTIONS

#define ACLITEM_SET_PRIVS_GOPTIONS (   item,
  privs,
  goptions 
)
Value:
((item).ai_privs = ((AclMode) (privs) & 0xFFFFFFFF) | \
(((AclMode) (goptions) & 0xFFFFFFFF) << 32))

Definition at line 82 of file acl.h.

◆ ACLITEM_SET_RIGHTS

#define ACLITEM_SET_RIGHTS (   item,
  rights 
)     ((item).ai_privs = (AclMode) (rights))

Definition at line 79 of file acl.h.

◆ DatumGetAclItemP

#define DatumGetAclItemP (   X)    ((AclItem *) DatumGetPointer(X))

Definition at line 116 of file acl.h.

◆ DatumGetAclP

#define DatumGetAclP (   X)    ((Acl *) PG_DETOAST_DATUM(X))

Definition at line 120 of file acl.h.

◆ DatumGetAclPCopy

#define DatumGetAclPCopy (   X)    ((Acl *) PG_DETOAST_DATUM_COPY(X))

Definition at line 121 of file acl.h.

◆ PG_GETARG_ACL_P

#define PG_GETARG_ACL_P (   n)    DatumGetAclP(PG_GETARG_DATUM(n))

Definition at line 122 of file acl.h.

◆ PG_GETARG_ACL_P_COPY

#define PG_GETARG_ACL_P_COPY (   n)    DatumGetAclPCopy(PG_GETARG_DATUM(n))

Definition at line 123 of file acl.h.

◆ PG_GETARG_ACLITEM_P

#define PG_GETARG_ACLITEM_P (   n)    DatumGetAclItemP(PG_GETARG_DATUM(n))

Definition at line 117 of file acl.h.

◆ PG_RETURN_ACL_P

#define PG_RETURN_ACL_P (   x)    PG_RETURN_POINTER(x)

Definition at line 124 of file acl.h.

◆ PG_RETURN_ACLITEM_P

#define PG_RETURN_ACLITEM_P (   x)    PG_RETURN_POINTER(x)

Definition at line 118 of file acl.h.

Typedef Documentation

◆ Acl

typedef struct ArrayType Acl

Definition at line 1 of file acl.h.

◆ AclItem

typedef struct AclItem AclItem

Enumeration Type Documentation

◆ AclMaskHow

enum AclMaskHow
Enumerator
ACLMASK_ALL 
ACLMASK_ANY 

Definition at line 174 of file acl.h.

175 {
176  ACLMASK_ALL, /* normal case: compute all bits */
177  ACLMASK_ANY, /* return when result is known nonzero */
178 } AclMaskHow;
AclMaskHow
Definition: acl.h:175
@ ACLMASK_ANY
Definition: acl.h:177
@ ACLMASK_ALL
Definition: acl.h:176

◆ AclResult

enum AclResult
Enumerator
ACLCHECK_OK 
ACLCHECK_NO_PRIV 
ACLCHECK_NOT_OWNER 

Definition at line 181 of file acl.h.

182 {
183  ACLCHECK_OK = 0,
186 } AclResult;
AclResult
Definition: acl.h:182
@ ACLCHECK_NO_PRIV
Definition: acl.h:184
@ ACLCHECK_OK
Definition: acl.h:183
@ ACLCHECK_NOT_OWNER
Definition: acl.h:185

Function Documentation

◆ aclcheck_error()

void aclcheck_error ( AclResult  aclerr,
ObjectType  objtype,
const char *  objectname 
)

Definition at line 2688 of file aclchk.c.

2690 {
2691  switch (aclerr)
2692  {
2693  case ACLCHECK_OK:
2694  /* no error, so return to caller */
2695  break;
2696  case ACLCHECK_NO_PRIV:
2697  {
2698  const char *msg = "???";
2699 
2700  switch (objtype)
2701  {
2702  case OBJECT_AGGREGATE:
2703  msg = gettext_noop("permission denied for aggregate %s");
2704  break;
2705  case OBJECT_COLLATION:
2706  msg = gettext_noop("permission denied for collation %s");
2707  break;
2708  case OBJECT_COLUMN:
2709  msg = gettext_noop("permission denied for column %s");
2710  break;
2711  case OBJECT_CONVERSION:
2712  msg = gettext_noop("permission denied for conversion %s");
2713  break;
2714  case OBJECT_DATABASE:
2715  msg = gettext_noop("permission denied for database %s");
2716  break;
2717  case OBJECT_DOMAIN:
2718  msg = gettext_noop("permission denied for domain %s");
2719  break;
2720  case OBJECT_EVENT_TRIGGER:
2721  msg = gettext_noop("permission denied for event trigger %s");
2722  break;
2723  case OBJECT_EXTENSION:
2724  msg = gettext_noop("permission denied for extension %s");
2725  break;
2726  case OBJECT_FDW:
2727  msg = gettext_noop("permission denied for foreign-data wrapper %s");
2728  break;
2729  case OBJECT_FOREIGN_SERVER:
2730  msg = gettext_noop("permission denied for foreign server %s");
2731  break;
2732  case OBJECT_FOREIGN_TABLE:
2733  msg = gettext_noop("permission denied for foreign table %s");
2734  break;
2735  case OBJECT_FUNCTION:
2736  msg = gettext_noop("permission denied for function %s");
2737  break;
2738  case OBJECT_INDEX:
2739  msg = gettext_noop("permission denied for index %s");
2740  break;
2741  case OBJECT_LANGUAGE:
2742  msg = gettext_noop("permission denied for language %s");
2743  break;
2744  case OBJECT_LARGEOBJECT:
2745  msg = gettext_noop("permission denied for large object %s");
2746  break;
2747  case OBJECT_MATVIEW:
2748  msg = gettext_noop("permission denied for materialized view %s");
2749  break;
2750  case OBJECT_OPCLASS:
2751  msg = gettext_noop("permission denied for operator class %s");
2752  break;
2753  case OBJECT_OPERATOR:
2754  msg = gettext_noop("permission denied for operator %s");
2755  break;
2756  case OBJECT_OPFAMILY:
2757  msg = gettext_noop("permission denied for operator family %s");
2758  break;
2759  case OBJECT_PARAMETER_ACL:
2760  msg = gettext_noop("permission denied for parameter %s");
2761  break;
2762  case OBJECT_POLICY:
2763  msg = gettext_noop("permission denied for policy %s");
2764  break;
2765  case OBJECT_PROCEDURE:
2766  msg = gettext_noop("permission denied for procedure %s");
2767  break;
2768  case OBJECT_PUBLICATION:
2769  msg = gettext_noop("permission denied for publication %s");
2770  break;
2771  case OBJECT_ROUTINE:
2772  msg = gettext_noop("permission denied for routine %s");
2773  break;
2774  case OBJECT_SCHEMA:
2775  msg = gettext_noop("permission denied for schema %s");
2776  break;
2777  case OBJECT_SEQUENCE:
2778  msg = gettext_noop("permission denied for sequence %s");
2779  break;
2780  case OBJECT_STATISTIC_EXT:
2781  msg = gettext_noop("permission denied for statistics object %s");
2782  break;
2783  case OBJECT_SUBSCRIPTION:
2784  msg = gettext_noop("permission denied for subscription %s");
2785  break;
2786  case OBJECT_TABLE:
2787  msg = gettext_noop("permission denied for table %s");
2788  break;
2789  case OBJECT_TABLESPACE:
2790  msg = gettext_noop("permission denied for tablespace %s");
2791  break;
2793  msg = gettext_noop("permission denied for text search configuration %s");
2794  break;
2795  case OBJECT_TSDICTIONARY:
2796  msg = gettext_noop("permission denied for text search dictionary %s");
2797  break;
2798  case OBJECT_TYPE:
2799  msg = gettext_noop("permission denied for type %s");
2800  break;
2801  case OBJECT_VIEW:
2802  msg = gettext_noop("permission denied for view %s");
2803  break;
2804  /* these currently aren't used */
2805  case OBJECT_ACCESS_METHOD:
2806  case OBJECT_AMOP:
2807  case OBJECT_AMPROC:
2808  case OBJECT_ATTRIBUTE:
2809  case OBJECT_CAST:
2810  case OBJECT_DEFAULT:
2811  case OBJECT_DEFACL:
2812  case OBJECT_DOMCONSTRAINT:
2815  case OBJECT_ROLE:
2816  case OBJECT_RULE:
2817  case OBJECT_TABCONSTRAINT:
2818  case OBJECT_TRANSFORM:
2819  case OBJECT_TRIGGER:
2820  case OBJECT_TSPARSER:
2821  case OBJECT_TSTEMPLATE:
2822  case OBJECT_USER_MAPPING:
2823  elog(ERROR, "unsupported object type: %d", objtype);
2824  }
2825 
2826  ereport(ERROR,
2827  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2828  errmsg(msg, objectname)));
2829  break;
2830  }
2831  case ACLCHECK_NOT_OWNER:
2832  {
2833  const char *msg = "???";
2834 
2835  switch (objtype)
2836  {
2837  case OBJECT_AGGREGATE:
2838  msg = gettext_noop("must be owner of aggregate %s");
2839  break;
2840  case OBJECT_COLLATION:
2841  msg = gettext_noop("must be owner of collation %s");
2842  break;
2843  case OBJECT_CONVERSION:
2844  msg = gettext_noop("must be owner of conversion %s");
2845  break;
2846  case OBJECT_DATABASE:
2847  msg = gettext_noop("must be owner of database %s");
2848  break;
2849  case OBJECT_DOMAIN:
2850  msg = gettext_noop("must be owner of domain %s");
2851  break;
2852  case OBJECT_EVENT_TRIGGER:
2853  msg = gettext_noop("must be owner of event trigger %s");
2854  break;
2855  case OBJECT_EXTENSION:
2856  msg = gettext_noop("must be owner of extension %s");
2857  break;
2858  case OBJECT_FDW:
2859  msg = gettext_noop("must be owner of foreign-data wrapper %s");
2860  break;
2861  case OBJECT_FOREIGN_SERVER:
2862  msg = gettext_noop("must be owner of foreign server %s");
2863  break;
2864  case OBJECT_FOREIGN_TABLE:
2865  msg = gettext_noop("must be owner of foreign table %s");
2866  break;
2867  case OBJECT_FUNCTION:
2868  msg = gettext_noop("must be owner of function %s");
2869  break;
2870  case OBJECT_INDEX:
2871  msg = gettext_noop("must be owner of index %s");
2872  break;
2873  case OBJECT_LANGUAGE:
2874  msg = gettext_noop("must be owner of language %s");
2875  break;
2876  case OBJECT_LARGEOBJECT:
2877  msg = gettext_noop("must be owner of large object %s");
2878  break;
2879  case OBJECT_MATVIEW:
2880  msg = gettext_noop("must be owner of materialized view %s");
2881  break;
2882  case OBJECT_OPCLASS:
2883  msg = gettext_noop("must be owner of operator class %s");
2884  break;
2885  case OBJECT_OPERATOR:
2886  msg = gettext_noop("must be owner of operator %s");
2887  break;
2888  case OBJECT_OPFAMILY:
2889  msg = gettext_noop("must be owner of operator family %s");
2890  break;
2891  case OBJECT_PROCEDURE:
2892  msg = gettext_noop("must be owner of procedure %s");
2893  break;
2894  case OBJECT_PUBLICATION:
2895  msg = gettext_noop("must be owner of publication %s");
2896  break;
2897  case OBJECT_ROUTINE:
2898  msg = gettext_noop("must be owner of routine %s");
2899  break;
2900  case OBJECT_SEQUENCE:
2901  msg = gettext_noop("must be owner of sequence %s");
2902  break;
2903  case OBJECT_SUBSCRIPTION:
2904  msg = gettext_noop("must be owner of subscription %s");
2905  break;
2906  case OBJECT_TABLE:
2907  msg = gettext_noop("must be owner of table %s");
2908  break;
2909  case OBJECT_TYPE:
2910  msg = gettext_noop("must be owner of type %s");
2911  break;
2912  case OBJECT_VIEW:
2913  msg = gettext_noop("must be owner of view %s");
2914  break;
2915  case OBJECT_SCHEMA:
2916  msg = gettext_noop("must be owner of schema %s");
2917  break;
2918  case OBJECT_STATISTIC_EXT:
2919  msg = gettext_noop("must be owner of statistics object %s");
2920  break;
2921  case OBJECT_TABLESPACE:
2922  msg = gettext_noop("must be owner of tablespace %s");
2923  break;
2925  msg = gettext_noop("must be owner of text search configuration %s");
2926  break;
2927  case OBJECT_TSDICTIONARY:
2928  msg = gettext_noop("must be owner of text search dictionary %s");
2929  break;
2930 
2931  /*
2932  * Special cases: For these, the error message talks
2933  * about "relation", because that's where the
2934  * ownership is attached. See also
2935  * check_object_ownership().
2936  */
2937  case OBJECT_COLUMN:
2938  case OBJECT_POLICY:
2939  case OBJECT_RULE:
2940  case OBJECT_TABCONSTRAINT:
2941  case OBJECT_TRIGGER:
2942  msg = gettext_noop("must be owner of relation %s");
2943  break;
2944  /* these currently aren't used */
2945  case OBJECT_ACCESS_METHOD:
2946  case OBJECT_AMOP:
2947  case OBJECT_AMPROC:
2948  case OBJECT_ATTRIBUTE:
2949  case OBJECT_CAST:
2950  case OBJECT_DEFAULT:
2951  case OBJECT_DEFACL:
2952  case OBJECT_DOMCONSTRAINT:
2953  case OBJECT_PARAMETER_ACL:
2956  case OBJECT_ROLE:
2957  case OBJECT_TRANSFORM:
2958  case OBJECT_TSPARSER:
2959  case OBJECT_TSTEMPLATE:
2960  case OBJECT_USER_MAPPING:
2961  elog(ERROR, "unsupported object type: %d", objtype);
2962  }
2963 
2964  ereport(ERROR,
2965  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2966  errmsg(msg, objectname)));
2967  break;
2968  }
2969  default:
2970  elog(ERROR, "unrecognized AclResult: %d", (int) aclerr);
2971  break;
2972  }
2973 }
#define gettext_noop(x)
Definition: c.h:1183
int errcode(int sqlerrcode)
Definition: elog.c:859
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
@ OBJECT_EVENT_TRIGGER
Definition: parsenodes.h:2123
@ OBJECT_FDW
Definition: parsenodes.h:2125
@ OBJECT_TSPARSER
Definition: parsenodes.h:2156
@ OBJECT_COLLATION
Definition: parsenodes.h:2116
@ OBJECT_USER_MAPPING
Definition: parsenodes.h:2159
@ OBJECT_ACCESS_METHOD
Definition: parsenodes.h:2109
@ OBJECT_OPCLASS
Definition: parsenodes.h:2133
@ OBJECT_DEFACL
Definition: parsenodes.h:2120
@ OBJECT_AGGREGATE
Definition: parsenodes.h:2110
@ OBJECT_MATVIEW
Definition: parsenodes.h:2132
@ OBJECT_SCHEMA
Definition: parsenodes.h:2145
@ OBJECT_POLICY
Definition: parsenodes.h:2137
@ OBJECT_OPERATOR
Definition: parsenodes.h:2134
@ OBJECT_FOREIGN_TABLE
Definition: parsenodes.h:2127
@ OBJECT_TSCONFIGURATION
Definition: parsenodes.h:2154
@ OBJECT_OPFAMILY
Definition: parsenodes.h:2135
@ OBJECT_DOMAIN
Definition: parsenodes.h:2121
@ OBJECT_COLUMN
Definition: parsenodes.h:2115
@ OBJECT_TABLESPACE
Definition: parsenodes.h:2151
@ OBJECT_ROLE
Definition: parsenodes.h:2142
@ OBJECT_ROUTINE
Definition: parsenodes.h:2143
@ OBJECT_LARGEOBJECT
Definition: parsenodes.h:2131
@ OBJECT_PUBLICATION_NAMESPACE
Definition: parsenodes.h:2140
@ OBJECT_PROCEDURE
Definition: parsenodes.h:2138
@ OBJECT_EXTENSION
Definition: parsenodes.h:2124
@ OBJECT_INDEX
Definition: parsenodes.h:2129
@ OBJECT_DEFAULT
Definition: parsenodes.h:2119
@ OBJECT_DATABASE
Definition: parsenodes.h:2118
@ OBJECT_SEQUENCE
Definition: parsenodes.h:2146
@ OBJECT_TSTEMPLATE
Definition: parsenodes.h:2157
@ OBJECT_LANGUAGE
Definition: parsenodes.h:2130
@ OBJECT_AMOP
Definition: parsenodes.h:2111
@ OBJECT_PUBLICATION_REL
Definition: parsenodes.h:2141
@ OBJECT_FOREIGN_SERVER
Definition: parsenodes.h:2126
@ OBJECT_TSDICTIONARY
Definition: parsenodes.h:2155
@ OBJECT_ATTRIBUTE
Definition: parsenodes.h:2113
@ OBJECT_PUBLICATION
Definition: parsenodes.h:2139
@ OBJECT_RULE
Definition: parsenodes.h:2144
@ OBJECT_CONVERSION
Definition: parsenodes.h:2117
@ OBJECT_AMPROC
Definition: parsenodes.h:2112
@ OBJECT_TABLE
Definition: parsenodes.h:2150
@ OBJECT_VIEW
Definition: parsenodes.h:2160
@ OBJECT_PARAMETER_ACL
Definition: parsenodes.h:2136
@ OBJECT_TYPE
Definition: parsenodes.h:2158
@ OBJECT_FUNCTION
Definition: parsenodes.h:2128
@ OBJECT_TABCONSTRAINT
Definition: parsenodes.h:2149
@ OBJECT_DOMCONSTRAINT
Definition: parsenodes.h:2122
@ OBJECT_SUBSCRIPTION
Definition: parsenodes.h:2147
@ OBJECT_STATISTIC_EXT
Definition: parsenodes.h:2148
@ OBJECT_CAST
Definition: parsenodes.h:2114
@ OBJECT_TRIGGER
Definition: parsenodes.h:2153
@ OBJECT_TRANSFORM
Definition: parsenodes.h:2152

References ACLCHECK_NO_PRIV, ACLCHECK_NOT_OWNER, ACLCHECK_OK, elog, ereport, errcode(), errmsg(), ERROR, gettext_noop, OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_AMOP, OBJECT_AMPROC, OBJECT_ATTRIBUTE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DEFACL, OBJECT_DEFAULT, OBJECT_DOMAIN, OBJECT_DOMCONSTRAINT, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_PARAMETER_ACL, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_PUBLICATION_NAMESPACE, OBJECT_PUBLICATION_REL, OBJECT_ROLE, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TRANSFORM, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_USER_MAPPING, and OBJECT_VIEW.

Referenced by aclcheck_error_col(), aclcheck_error_type(), AlterCollation(), AlterDatabase(), AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterDatabaseSet(), AlterEventTrigger(), AlterEventTriggerOwner_internal(), AlterExtensionNamespace(), AlterForeignServer(), AlterForeignServerOwner_internal(), AlterFunction(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), AlterOperator(), AlterOpFamilyAdd(), AlterPublication(), AlterPublicationOwner_internal(), AlterRoleSet(), AlterSchemaOwner_internal(), AlterStatistics(), AlterSubscription(), AlterSubscriptionOwner_internal(), AlterTableMoveAll(), AlterTableSpaceOptions(), AlterTSConfiguration(), AlterTSDictionary(), AlterTypeOwner(), ATExecChangeOwner(), ATPrepSetTableSpace(), ATSimplePermissions(), brin_desummarize_range(), brin_summarize_range(), calculate_database_size(), calculate_tablespace_size(), call_pltcl_start_proc(), check_object_ownership(), check_temp_tablespaces(), checkFkeyPermissions(), CheckFunctionValidatorAccess(), compute_return_type(), CreateConversionCommand(), createdb(), CreateForeignServer(), CreateForeignTable(), CreateFunction(), CreateProceduralLanguage(), CreatePublication(), CreateSchemaCommand(), CreateStatistics(), CreateSubscription(), CreateTransform(), CreateTriggerFiringOn(), currtid_internal(), DefineAggregate(), DefineCollation(), DefineDomain(), DefineEnum(), DefineIndex(), DefineOpClass(), DefineOperator(), DefineOpFamily(), DefineQueryRewrite(), DefineRange(), DefineRelation(), DefineTSConfiguration(), DefineTSDictionary(), DefineType(), dropdb(), DropSubscription(), DropTableSpace(), EnableDisableRule(), ExecAlterExtensionContentsStmt(), ExecAlterExtensionStmt(), ExecBuildGroupingEqual(), ExecBuildParamSetEqual(), ExecCheckPermissions(), ExecInitAgg(), ExecInitExprRec(), ExecInitFunc(), ExecInitWindowAgg(), ExecReindex(), ExecuteCallStmt(), ExecuteDoStmt(), ExecuteTruncateGuts(), findRangeCanonicalFunction(), findRangeSubtypeDiffFunction(), get_connect_string(), get_other_operator(), get_rel_from_relname(), gin_clean_pending_list(), HandleFunctionRequest(), heap_force_common(), ImportForeignSchema(), init_sexpr(), initialize_peragg(), LockViewRecurse_walker(), LogicalRepSyncTableStart(), lookup_agg_function(), LookupCreationNamespace(), LookupExplicitNamespace(), MergeAttributes(), movedb(), OperatorCreate(), pg_prewarm(), pgrowlocks(), ProcedureCreate(), PublicationAddTables(), RangeVarCallbackForAlterRelation(), RangeVarCallbackForDropRelation(), RangeVarCallbackForLockTable(), RangeVarCallbackForPolicy(), RangeVarCallbackForReindexIndex(), RangeVarCallbackForRenameRule(), RangeVarCallbackForRenameTrigger(), RangeVarCallbackMaintainsTable(), RangeVarCallbackOwnsRelation(), RangeVarGetAndCheckCreationNamespace(), ReindexMultipleInternal(), ReindexMultipleTables(), renameatt_check(), RenameDatabase(), RenameSchema(), RenameTableSpace(), restrict_and_check_grant(), TargetPrivilegesCheck(), transformTableLikeClause(), truncate_check_perms(), TypeCreate(), user_mapping_ddl_aclcheck(), ValidateJoinEstimator(), ValidateOperatorReference(), and ValidateRestrictionEstimator().

◆ aclcheck_error_col()

void aclcheck_error_col ( AclResult  aclerr,
ObjectType  objtype,
const char *  objectname,
const char *  colname 
)

Definition at line 2977 of file aclchk.c.

2979 {
2980  switch (aclerr)
2981  {
2982  case ACLCHECK_OK:
2983  /* no error, so return to caller */
2984  break;
2985  case ACLCHECK_NO_PRIV:
2986  ereport(ERROR,
2987  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2988  errmsg("permission denied for column \"%s\" of relation \"%s\"",
2989  colname, objectname)));
2990  break;
2991  case ACLCHECK_NOT_OWNER:
2992  /* relation msg is OK since columns don't have separate owners */
2993  aclcheck_error(aclerr, objtype, objectname);
2994  break;
2995  default:
2996  elog(ERROR, "unrecognized AclResult: %d", (int) aclerr);
2997  break;
2998  }
2999 }
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2688

References aclcheck_error(), ACLCHECK_NO_PRIV, ACLCHECK_NOT_OWNER, ACLCHECK_OK, elog, ereport, errcode(), errmsg(), and ERROR.

Referenced by restrict_and_check_grant().

◆ aclcheck_error_type()

void aclcheck_error_type ( AclResult  aclerr,
Oid  typeOid 
)

◆ aclconcat()

Acl* aclconcat ( const Acl left_acl,
const Acl right_acl 
)

Definition at line 452 of file acl.c.

453 {
454  Acl *result_acl;
455 
456  result_acl = allocacl(ACL_NUM(left_acl) + ACL_NUM(right_acl));
457 
458  memcpy(ACL_DAT(result_acl),
459  ACL_DAT(left_acl),
460  ACL_NUM(left_acl) * sizeof(AclItem));
461 
462  memcpy(ACL_DAT(result_acl) + ACL_NUM(left_acl),
463  ACL_DAT(right_acl),
464  ACL_NUM(right_acl) * sizeof(AclItem));
465 
466  return result_acl;
467 }
static Acl * allocacl(int n)
Definition: acl.c:401
#define ACL_DAT(ACL)
Definition: acl.h:109
#define ACL_NUM(ACL)
Definition: acl.h:108
Definition: acl.h:55

References ACL_DAT, ACL_NUM, and allocacl().

Referenced by ExecGrant_Attribute().

◆ aclcopy()

Acl* aclcopy ( const Acl orig_acl)

Definition at line 432 of file acl.c.

433 {
434  Acl *result_acl;
435 
436  result_acl = allocacl(ACL_NUM(orig_acl));
437 
438  memcpy(ACL_DAT(result_acl),
439  ACL_DAT(orig_acl),
440  ACL_NUM(orig_acl) * sizeof(AclItem));
441 
442  return result_acl;
443 }

References ACL_DAT, ACL_NUM, and allocacl().

Referenced by aclmerge(), ExecGrant_Relation(), and SetDefaultACL().

◆ acldefault()

Acl* acldefault ( ObjectType  objtype,
Oid  ownerId 
)

Definition at line 778 of file acl.c.

779 {
780  AclMode world_default;
781  AclMode owner_default;
782  int nacl;
783  Acl *acl;
784  AclItem *aip;
785 
786  switch (objtype)
787  {
788  case OBJECT_COLUMN:
789  /* by default, columns have no extra privileges */
790  world_default = ACL_NO_RIGHTS;
791  owner_default = ACL_NO_RIGHTS;
792  break;
793  case OBJECT_TABLE:
794  world_default = ACL_NO_RIGHTS;
795  owner_default = ACL_ALL_RIGHTS_RELATION;
796  break;
797  case OBJECT_SEQUENCE:
798  world_default = ACL_NO_RIGHTS;
799  owner_default = ACL_ALL_RIGHTS_SEQUENCE;
800  break;
801  case OBJECT_DATABASE:
802  /* for backwards compatibility, grant some rights by default */
803  world_default = ACL_CREATE_TEMP | ACL_CONNECT;
804  owner_default = ACL_ALL_RIGHTS_DATABASE;
805  break;
806  case OBJECT_FUNCTION:
807  /* Grant EXECUTE by default, for now */
808  world_default = ACL_EXECUTE;
809  owner_default = ACL_ALL_RIGHTS_FUNCTION;
810  break;
811  case OBJECT_LANGUAGE:
812  /* Grant USAGE by default, for now */
813  world_default = ACL_USAGE;
814  owner_default = ACL_ALL_RIGHTS_LANGUAGE;
815  break;
816  case OBJECT_LARGEOBJECT:
817  world_default = ACL_NO_RIGHTS;
818  owner_default = ACL_ALL_RIGHTS_LARGEOBJECT;
819  break;
820  case OBJECT_SCHEMA:
821  world_default = ACL_NO_RIGHTS;
822  owner_default = ACL_ALL_RIGHTS_SCHEMA;
823  break;
824  case OBJECT_TABLESPACE:
825  world_default = ACL_NO_RIGHTS;
826  owner_default = ACL_ALL_RIGHTS_TABLESPACE;
827  break;
828  case OBJECT_FDW:
829  world_default = ACL_NO_RIGHTS;
830  owner_default = ACL_ALL_RIGHTS_FDW;
831  break;
833  world_default = ACL_NO_RIGHTS;
834  owner_default = ACL_ALL_RIGHTS_FOREIGN_SERVER;
835  break;
836  case OBJECT_DOMAIN:
837  case OBJECT_TYPE:
838  world_default = ACL_USAGE;
839  owner_default = ACL_ALL_RIGHTS_TYPE;
840  break;
842  world_default = ACL_NO_RIGHTS;
843  owner_default = ACL_ALL_RIGHTS_PARAMETER_ACL;
844  break;
845  default:
846  elog(ERROR, "unrecognized object type: %d", (int) objtype);
847  world_default = ACL_NO_RIGHTS; /* keep compiler quiet */
848  owner_default = ACL_NO_RIGHTS;
849  break;
850  }
851 
852  nacl = 0;
853  if (world_default != ACL_NO_RIGHTS)
854  nacl++;
855  if (owner_default != ACL_NO_RIGHTS)
856  nacl++;
857 
858  acl = allocacl(nacl);
859  aip = ACL_DAT(acl);
860 
861  if (world_default != ACL_NO_RIGHTS)
862  {
863  aip->ai_grantee = ACL_ID_PUBLIC;
864  aip->ai_grantor = ownerId;
865  ACLITEM_SET_PRIVS_GOPTIONS(*aip, world_default, ACL_NO_RIGHTS);
866  aip++;
867  }
868 
869  /*
870  * Note that the owner's entry shows all ordinary privileges but no grant
871  * options. This is because his grant options come "from the system" and
872  * not from his own efforts. (The SQL spec says that the owner's rights
873  * come from a "_SYSTEM" authid.) However, we do consider that the
874  * owner's ordinary privileges are self-granted; this lets him revoke
875  * them. We implement the owner's grant options without any explicit
876  * "_SYSTEM"-like ACL entry, by internally special-casing the owner
877  * wherever we are testing grant options.
878  */
879  if (owner_default != ACL_NO_RIGHTS)
880  {
881  aip->ai_grantee = ownerId;
882  aip->ai_grantor = ownerId;
883  ACLITEM_SET_PRIVS_GOPTIONS(*aip, owner_default, ACL_NO_RIGHTS);
884  }
885 
886  return acl;
887 }
#define ACL_ALL_RIGHTS_FOREIGN_SERVER
Definition: acl.h:164
#define ACL_ALL_RIGHTS_TABLESPACE
Definition: acl.h:170
#define ACL_ALL_RIGHTS_PARAMETER_ACL
Definition: acl.h:168
#define ACL_ALL_RIGHTS_SCHEMA
Definition: acl.h:169
#define ACL_ALL_RIGHTS_SEQUENCE
Definition: acl.h:161
#define ACL_ALL_RIGHTS_DATABASE
Definition: acl.h:162
#define ACL_ALL_RIGHTS_FUNCTION
Definition: acl.h:165
#define ACL_ALL_RIGHTS_LANGUAGE
Definition: acl.h:166
#define ACL_ALL_RIGHTS_TYPE
Definition: acl.h:171
#define ACL_ALL_RIGHTS_FDW
Definition: acl.h:163
#define ACLITEM_SET_PRIVS_GOPTIONS(item, privs, goptions)
Definition: acl.h:82
#define ACL_ALL_RIGHTS_RELATION
Definition: acl.h:160
#define ACL_ID_PUBLIC
Definition: acl.h:46
#define ACL_ALL_RIGHTS_LARGEOBJECT
Definition: acl.h:167
#define ACL_CREATE_TEMP
Definition: parsenodes.h:86
#define ACL_USAGE
Definition: parsenodes.h:84
#define ACL_NO_RIGHTS
Definition: parsenodes.h:92
#define ACL_CONNECT
Definition: parsenodes.h:87
#define ACL_EXECUTE
Definition: parsenodes.h:83
Oid ai_grantee
Definition: acl.h:56
Oid ai_grantor
Definition: acl.h:57

References ACL_ALL_RIGHTS_DATABASE, ACL_ALL_RIGHTS_FDW, ACL_ALL_RIGHTS_FOREIGN_SERVER, ACL_ALL_RIGHTS_FUNCTION, ACL_ALL_RIGHTS_LANGUAGE, ACL_ALL_RIGHTS_LARGEOBJECT, ACL_ALL_RIGHTS_PARAMETER_ACL, ACL_ALL_RIGHTS_RELATION, ACL_ALL_RIGHTS_SCHEMA, ACL_ALL_RIGHTS_SEQUENCE, ACL_ALL_RIGHTS_TABLESPACE, ACL_ALL_RIGHTS_TYPE, ACL_CONNECT, ACL_CREATE_TEMP, ACL_DAT, ACL_EXECUTE, ACL_ID_PUBLIC, ACL_NO_RIGHTS, ACL_USAGE, ACLITEM_SET_PRIVS_GOPTIONS, AclItem::ai_grantee, AclItem::ai_grantor, allocacl(), elog, ERROR, OBJECT_COLUMN, OBJECT_DATABASE, OBJECT_DOMAIN, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FUNCTION, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_PARAMETER_ACL, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_TABLESPACE, and OBJECT_TYPE.

Referenced by acldefault_sql(), buildDefaultACLCommands(), dumpACL(), dumpRoleGUCPrivs(), dumpTable(), dumpTablespaces(), ExecGrant_Attribute(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), ExecGrant_Relation(), get_user_default_acl(), object_aclmask_ext(), pg_class_aclmask_ext(), pg_largeobject_aclmask_snapshot(), pg_namespace_aclmask_ext(), pg_parameter_acl_aclmask(), pg_parameter_aclmask(), pg_type_aclmask_ext(), and SetDefaultACL().

◆ aclequal()

bool aclequal ( const Acl left_acl,
const Acl right_acl 
)

Definition at line 534 of file acl.c.

535 {
536  /* Check for cases where one or both are empty/null */
537  if (left_acl == NULL || ACL_NUM(left_acl) == 0)
538  {
539  if (right_acl == NULL || ACL_NUM(right_acl) == 0)
540  return true;
541  else
542  return false;
543  }
544  else
545  {
546  if (right_acl == NULL || ACL_NUM(right_acl) == 0)
547  return false;
548  }
549 
550  if (ACL_NUM(left_acl) != ACL_NUM(right_acl))
551  return false;
552 
553  if (memcmp(ACL_DAT(left_acl),
554  ACL_DAT(right_acl),
555  ACL_NUM(left_acl) * sizeof(AclItem)) == 0)
556  return true;
557 
558  return false;
559 }

References ACL_DAT, and ACL_NUM.

Referenced by ExecGrant_Parameter(), get_user_default_acl(), and SetDefaultACL().

◆ aclitemsort()

void aclitemsort ( Acl acl)

Definition at line 520 of file acl.c.

521 {
522  if (acl != NULL && ACL_NUM(acl) > 1)
523  qsort(ACL_DAT(acl), ACL_NUM(acl), sizeof(AclItem), aclitemComparator);
524 }
static int aclitemComparator(const void *arg1, const void *arg2)
Definition: acl.c:699
#define qsort(a, b, c, d)
Definition: port.h:449

References ACL_DAT, ACL_NUM, aclitemComparator(), and qsort.

Referenced by get_user_default_acl(), and SetDefaultACL().

◆ aclmask()

AclMode aclmask ( const Acl acl,
Oid  roleid,
Oid  ownerId,
AclMode  mask,
AclMaskHow  how 
)

Definition at line 1357 of file acl.c.

1359 {
1360  AclMode result;
1362  AclItem *aidat;
1363  int i,
1364  num;
1365 
1366  /*
1367  * Null ACL should not happen, since caller should have inserted
1368  * appropriate default
1369  */
1370  if (acl == NULL)
1371  elog(ERROR, "null ACL");
1372 
1373  check_acl(acl);
1374 
1375  /* Quick exit for mask == 0 */
1376  if (mask == 0)
1377  return 0;
1378 
1379  result = 0;
1380 
1381  /* Owner always implicitly has all grant options */
1382  if ((mask & ACLITEM_ALL_GOPTION_BITS) &&
1383  has_privs_of_role(roleid, ownerId))
1384  {
1385  result = mask & ACLITEM_ALL_GOPTION_BITS;
1386  if ((how == ACLMASK_ALL) ? (result == mask) : (result != 0))
1387  return result;
1388  }
1389 
1390  num = ACL_NUM(acl);
1391  aidat = ACL_DAT(acl);
1392 
1393  /*
1394  * Check privileges granted directly to roleid or to public
1395  */
1396  for (i = 0; i < num; i++)
1397  {
1398  AclItem *aidata = &aidat[i];
1399 
1400  if (aidata->ai_grantee == ACL_ID_PUBLIC ||
1401  aidata->ai_grantee == roleid)
1402  {
1403  result |= aidata->ai_privs & mask;
1404  if ((how == ACLMASK_ALL) ? (result == mask) : (result != 0))
1405  return result;
1406  }
1407  }
1408 
1409  /*
1410  * Check privileges granted indirectly via role memberships. We do this in
1411  * a separate pass to minimize expensive indirect membership tests. In
1412  * particular, it's worth testing whether a given ACL entry grants any
1413  * privileges still of interest before we perform the has_privs_of_role
1414  * test.
1415  */
1416  remaining = mask & ~result;
1417  for (i = 0; i < num; i++)
1418  {
1419  AclItem *aidata = &aidat[i];
1420 
1421  if (aidata->ai_grantee == ACL_ID_PUBLIC ||
1422  aidata->ai_grantee == roleid)
1423  continue; /* already checked it */
1424 
1425  if ((aidata->ai_privs & remaining) &&
1426  has_privs_of_role(roleid, aidata->ai_grantee))
1427  {
1428  result |= aidata->ai_privs & mask;
1429  if ((how == ACLMASK_ALL) ? (result == mask) : (result != 0))
1430  return result;
1431  remaining = mask & ~result;
1432  }
1433  }
1434 
1435  return result;
1436 }
static void check_acl(const Acl *acl)
Definition: acl.c:565
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:5066
#define ACLITEM_ALL_GOPTION_BITS
Definition: acl.h:88
int remaining
Definition: informix.c:667
int i
Definition: isn.c:73
AclMode ai_privs
Definition: acl.h:58

References ACL_DAT, ACL_ID_PUBLIC, ACL_NUM, ACLITEM_ALL_GOPTION_BITS, ACLMASK_ALL, AclItem::ai_grantee, AclItem::ai_privs, check_acl(), elog, ERROR, has_privs_of_role(), i, and remaining.

Referenced by check_circularity(), LockTableAclCheck(), object_aclmask_ext(), pg_attribute_aclcheck_all_ext(), pg_attribute_aclmask_ext(), pg_class_aclmask_ext(), pg_largeobject_aclmask_snapshot(), pg_namespace_aclmask_ext(), pg_parameter_acl_aclmask(), pg_parameter_aclmask(), pg_type_aclmask_ext(), and recursive_revoke().

◆ aclmembers()

int aclmembers ( const Acl acl,
Oid **  roleids 
)

Definition at line 1509 of file acl.c.

1510 {
1511  Oid *list;
1512  const AclItem *acldat;
1513  int i,
1514  j;
1515 
1516  if (acl == NULL || ACL_NUM(acl) == 0)
1517  {
1518  *roleids = NULL;
1519  return 0;
1520  }
1521 
1522  check_acl(acl);
1523 
1524  /* Allocate the worst-case space requirement */
1525  list = palloc(ACL_NUM(acl) * 2 * sizeof(Oid));
1526  acldat = ACL_DAT(acl);
1527 
1528  /*
1529  * Walk the ACL collecting mentioned RoleIds.
1530  */
1531  j = 0;
1532  for (i = 0; i < ACL_NUM(acl); i++)
1533  {
1534  const AclItem *ai = &acldat[i];
1535 
1536  if (ai->ai_grantee != ACL_ID_PUBLIC)
1537  list[j++] = ai->ai_grantee;
1538  /* grantor is currently never PUBLIC, but let's check anyway */
1539  if (ai->ai_grantor != ACL_ID_PUBLIC)
1540  list[j++] = ai->ai_grantor;
1541  }
1542 
1543  /* Sort the array */
1544  qsort(list, j, sizeof(Oid), oid_cmp);
1545 
1546  /*
1547  * We could repalloc the array down to minimum size, but it's hardly worth
1548  * it since it's only transient memory.
1549  */
1550  *roleids = list;
1551 
1552  /* Remove duplicates from the array */
1553  return qunique(list, j, sizeof(Oid), oid_cmp);
1554 }
int j
Definition: isn.c:74
void * palloc(Size size)
Definition: mcxt.c:1304
int oid_cmp(const void *p1, const void *p2)
Definition: oid.c:258
static size_t qunique(void *array, size_t elements, size_t width, int(*compare)(const void *, const void *))
Definition: qunique.h:21

References ACL_DAT, ACL_ID_PUBLIC, ACL_NUM, AclItem::ai_grantee, AclItem::ai_grantor, check_acl(), i, j, sort-test::list, oid_cmp(), palloc(), qsort, and qunique().

Referenced by ExecGrant_Attribute(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), ExecGrant_Relation(), recordDependencyOnNewAcl(), and SetDefaultACL().

◆ aclmerge()

Acl* aclmerge ( const Acl left_acl,
const Acl right_acl,
Oid  ownerId 
)

Definition at line 476 of file acl.c.

477 {
478  Acl *result_acl;
479  AclItem *aip;
480  int i,
481  num;
482 
483  /* Check for cases where one or both are empty/null */
484  if (left_acl == NULL || ACL_NUM(left_acl) == 0)
485  {
486  if (right_acl == NULL || ACL_NUM(right_acl) == 0)
487  return NULL;
488  else
489  return aclcopy(right_acl);
490  }
491  else
492  {
493  if (right_acl == NULL || ACL_NUM(right_acl) == 0)
494  return aclcopy(left_acl);
495  }
496 
497  /* Merge them the hard way, one item at a time */
498  result_acl = aclcopy(left_acl);
499 
500  aip = ACL_DAT(right_acl);
501  num = ACL_NUM(right_acl);
502 
503  for (i = 0; i < num; i++, aip++)
504  {
505  Acl *tmp_acl;
506 
507  tmp_acl = aclupdate(result_acl, aip, ACL_MODECHG_ADD,
508  ownerId, DROP_RESTRICT);
509  pfree(result_acl);
510  result_acl = tmp_acl;
511  }
512 
513  return result_acl;
514 }
Acl * aclupdate(const Acl *old_acl, const AclItem *mod_aip, int modechg, Oid ownerId, DropBehavior behavior)
Definition: acl.c:967
Acl * aclcopy(const Acl *orig_acl)
Definition: acl.c:432
#define ACL_MODECHG_ADD
Definition: acl.h:129
void pfree(void *pointer)
Definition: mcxt.c:1508
@ DROP_RESTRICT
Definition: parsenodes.h:2182

References ACL_DAT, ACL_MODECHG_ADD, ACL_NUM, aclcopy(), aclupdate(), DROP_RESTRICT, i, and pfree().

Referenced by get_user_default_acl().

◆ aclnewowner()

Acl* aclnewowner ( const Acl old_acl,
Oid  oldOwnerId,
Oid  newOwnerId 
)

Definition at line 1088 of file acl.c.

1089 {
1090  Acl *new_acl;
1091  AclItem *new_aip;
1092  AclItem *old_aip;
1093  AclItem *dst_aip;
1094  AclItem *src_aip;
1095  AclItem *targ_aip;
1096  bool newpresent = false;
1097  int dst,
1098  src,
1099  targ,
1100  num;
1101 
1102  check_acl(old_acl);
1103 
1104  /*
1105  * Make a copy of the given ACL, substituting new owner ID for old
1106  * wherever it appears as either grantor or grantee. Also note if the new
1107  * owner ID is already present.
1108  */
1109  num = ACL_NUM(old_acl);
1110  old_aip = ACL_DAT(old_acl);
1111  new_acl = allocacl(num);
1112  new_aip = ACL_DAT(new_acl);
1113  memcpy(new_aip, old_aip, num * sizeof(AclItem));
1114  for (dst = 0, dst_aip = new_aip; dst < num; dst++, dst_aip++)
1115  {
1116  if (dst_aip->ai_grantor == oldOwnerId)
1117  dst_aip->ai_grantor = newOwnerId;
1118  else if (dst_aip->ai_grantor == newOwnerId)
1119  newpresent = true;
1120  if (dst_aip->ai_grantee == oldOwnerId)
1121  dst_aip->ai_grantee = newOwnerId;
1122  else if (dst_aip->ai_grantee == newOwnerId)
1123  newpresent = true;
1124  }
1125 
1126  /*
1127  * If the old ACL contained any references to the new owner, then we may
1128  * now have generated an ACL containing duplicate entries. Find them and
1129  * merge them so that there are not duplicates. (This is relatively
1130  * expensive since we use a stupid O(N^2) algorithm, but it's unlikely to
1131  * be the normal case.)
1132  *
1133  * To simplify deletion of duplicate entries, we temporarily leave them in
1134  * the array but set their privilege masks to zero; when we reach such an
1135  * entry it's just skipped. (Thus, a side effect of this code will be to
1136  * remove privilege-free entries, should there be any in the input.) dst
1137  * is the next output slot, targ is the currently considered input slot
1138  * (always >= dst), and src scans entries to the right of targ looking for
1139  * duplicates. Once an entry has been emitted to dst it is known
1140  * duplicate-free and need not be considered anymore.
1141  */
1142  if (newpresent)
1143  {
1144  dst = 0;
1145  for (targ = 0, targ_aip = new_aip; targ < num; targ++, targ_aip++)
1146  {
1147  /* ignore if deleted in an earlier pass */
1148  if (ACLITEM_GET_RIGHTS(*targ_aip) == ACL_NO_RIGHTS)
1149  continue;
1150  /* find and merge any duplicates */
1151  for (src = targ + 1, src_aip = targ_aip + 1; src < num;
1152  src++, src_aip++)
1153  {
1154  if (ACLITEM_GET_RIGHTS(*src_aip) == ACL_NO_RIGHTS)
1155  continue;
1156  if (aclitem_match(targ_aip, src_aip))
1157  {
1158  ACLITEM_SET_RIGHTS(*targ_aip,
1159  ACLITEM_GET_RIGHTS(*targ_aip) |
1160  ACLITEM_GET_RIGHTS(*src_aip));
1161  /* mark the duplicate deleted */
1162  ACLITEM_SET_RIGHTS(*src_aip, ACL_NO_RIGHTS);
1163  }
1164  }
1165  /* and emit to output */
1166  new_aip[dst] = *targ_aip;
1167  dst++;
1168  }
1169  /* Adjust array size to be 'dst' items */
1170  ARR_DIMS(new_acl)[0] = dst;
1171  SET_VARSIZE(new_acl, ACL_N_SIZE(dst));
1172  }
1173 
1174  return new_acl;
1175 }
static bool aclitem_match(const AclItem *a1, const AclItem *a2)
Definition: acl.c:688
#define ACL_N_SIZE(N)
Definition: acl.h:110
#define ACLITEM_GET_RIGHTS(item)
Definition: acl.h:68
#define ACLITEM_SET_RIGHTS(item, rights)
Definition: acl.h:79
#define ARR_DIMS(a)
Definition: array.h:294
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305

References ACL_DAT, ACL_N_SIZE, ACL_NO_RIGHTS, ACL_NUM, ACLITEM_GET_RIGHTS, aclitem_match(), ACLITEM_SET_RIGHTS, AclItem::ai_grantee, AclItem::ai_grantor, allocacl(), ARR_DIMS, check_acl(), and SET_VARSIZE.

Referenced by AlterDatabaseOwner(), AlterForeignDataWrapperOwner_internal(), AlterForeignServerOwner_internal(), AlterObjectOwner_internal(), AlterSchemaOwner_internal(), AlterTypeOwnerInternal(), ATExecChangeOwner(), and change_owner_fix_column_acls().

◆ aclupdate()

Acl* aclupdate ( const Acl old_acl,
const AclItem mod_aip,
int  modechg,
Oid  ownerId,
DropBehavior  behavior 
)

Definition at line 967 of file acl.c.

969 {
970  Acl *new_acl = NULL;
971  AclItem *old_aip,
972  *new_aip = NULL;
973  AclMode old_rights,
974  old_goptions,
975  new_rights,
976  new_goptions;
977  int dst,
978  num;
979 
980  /* Caller probably already checked old_acl, but be safe */
981  check_acl(old_acl);
982 
983  /* If granting grant options, check for circularity */
984  if (modechg != ACL_MODECHG_DEL &&
985  ACLITEM_GET_GOPTIONS(*mod_aip) != ACL_NO_RIGHTS)
986  check_circularity(old_acl, mod_aip, ownerId);
987 
988  num = ACL_NUM(old_acl);
989  old_aip = ACL_DAT(old_acl);
990 
991  /*
992  * Search the ACL for an existing entry for this grantee and grantor. If
993  * one exists, just modify the entry in-place (well, in the same position,
994  * since we actually return a copy); otherwise, insert the new entry at
995  * the end.
996  */
997 
998  for (dst = 0; dst < num; ++dst)
999  {
1000  if (aclitem_match(mod_aip, old_aip + dst))
1001  {
1002  /* found a match, so modify existing item */
1003  new_acl = allocacl(num);
1004  new_aip = ACL_DAT(new_acl);
1005  memcpy(new_acl, old_acl, ACL_SIZE(old_acl));
1006  break;
1007  }
1008  }
1009 
1010  if (dst == num)
1011  {
1012  /* need to append a new item */
1013  new_acl = allocacl(num + 1);
1014  new_aip = ACL_DAT(new_acl);
1015  memcpy(new_aip, old_aip, num * sizeof(AclItem));
1016 
1017  /* initialize the new entry with no permissions */
1018  new_aip[dst].ai_grantee = mod_aip->ai_grantee;
1019  new_aip[dst].ai_grantor = mod_aip->ai_grantor;
1020  ACLITEM_SET_PRIVS_GOPTIONS(new_aip[dst],
1022  num++; /* set num to the size of new_acl */
1023  }
1024 
1025  old_rights = ACLITEM_GET_RIGHTS(new_aip[dst]);
1026  old_goptions = ACLITEM_GET_GOPTIONS(new_aip[dst]);
1027 
1028  /* apply the specified permissions change */
1029  switch (modechg)
1030  {
1031  case ACL_MODECHG_ADD:
1032  ACLITEM_SET_RIGHTS(new_aip[dst],
1033  old_rights | ACLITEM_GET_RIGHTS(*mod_aip));
1034  break;
1035  case ACL_MODECHG_DEL:
1036  ACLITEM_SET_RIGHTS(new_aip[dst],
1037  old_rights & ~ACLITEM_GET_RIGHTS(*mod_aip));
1038  break;
1039  case ACL_MODECHG_EQL:
1040  ACLITEM_SET_RIGHTS(new_aip[dst],
1041  ACLITEM_GET_RIGHTS(*mod_aip));
1042  break;
1043  }
1044 
1045  new_rights = ACLITEM_GET_RIGHTS(new_aip[dst]);
1046  new_goptions = ACLITEM_GET_GOPTIONS(new_aip[dst]);
1047 
1048  /*
1049  * If the adjusted entry has no permissions, delete it from the list.
1050  */
1051  if (new_rights == ACL_NO_RIGHTS)
1052  {
1053  memmove(new_aip + dst,
1054  new_aip + dst + 1,
1055  (num - dst - 1) * sizeof(AclItem));
1056  /* Adjust array size to be 'num - 1' items */
1057  ARR_DIMS(new_acl)[0] = num - 1;
1058  SET_VARSIZE(new_acl, ACL_N_SIZE(num - 1));
1059  }
1060 
1061  /*
1062  * Remove abandoned privileges (cascading revoke). Currently we can only
1063  * handle this when the grantee is not PUBLIC.
1064  */
1065  if ((old_goptions & ~new_goptions) != 0)
1066  {
1067  Assert(mod_aip->ai_grantee != ACL_ID_PUBLIC);
1068  new_acl = recursive_revoke(new_acl, mod_aip->ai_grantee,
1069  (old_goptions & ~new_goptions),
1070  ownerId, behavior);
1071  }
1072 
1073  return new_acl;
1074 }
static Acl * recursive_revoke(Acl *acl, Oid grantee, AclMode revoke_privs, Oid ownerId, DropBehavior behavior)
Definition: acl.c:1271
static void check_circularity(const Acl *old_acl, const AclItem *mod_aip, Oid ownerId)
Definition: acl.c:1191
#define ACL_SIZE(ACL)
Definition: acl.h:111
#define ACL_MODECHG_DEL
Definition: acl.h:130
#define ACLITEM_GET_GOPTIONS(item)
Definition: acl.h:67
#define ACL_MODECHG_EQL
Definition: acl.h:131
Assert(fmt[strlen(fmt) - 1] !='\n')

References ACL_DAT, ACL_ID_PUBLIC, ACL_MODECHG_ADD, ACL_MODECHG_DEL, ACL_MODECHG_EQL, ACL_N_SIZE, ACL_NO_RIGHTS, ACL_NUM, ACL_SIZE, ACLITEM_GET_GOPTIONS, ACLITEM_GET_RIGHTS, aclitem_match(), ACLITEM_SET_PRIVS_GOPTIONS, ACLITEM_SET_RIGHTS, AclItem::ai_grantee, AclItem::ai_grantor, allocacl(), ARR_DIMS, Assert(), check_acl(), check_circularity(), recursive_revoke(), and SET_VARSIZE.

Referenced by aclmerge(), check_circularity(), merge_acl_with_grant(), and recursive_revoke().

◆ check_can_set_role()

void check_can_set_role ( Oid  member,
Oid  role 
)

Definition at line 5123 of file acl.c.

5124 {
5125  if (!member_can_set_role(member, role))
5126  ereport(ERROR,
5127  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
5128  errmsg("must be able to SET ROLE \"%s\"",
5129  GetUserNameFromId(role, false))));
5130 }
bool member_can_set_role(Oid member, Oid role)
Definition: acl.c:5100
char * GetUserNameFromId(Oid roleid, bool noerr)
Definition: miscinit.c:980

References ereport, errcode(), errmsg(), ERROR, GetUserNameFromId(), and member_can_set_role().

Referenced by AlterDatabaseOwner(), AlterForeignServerOwner_internal(), AlterObjectOwner_internal(), AlterPublicationOwner_internal(), AlterSchemaOwner_internal(), AlterSubscriptionOwner_internal(), AlterTypeOwner(), ATExecChangeOwner(), createdb(), and CreateSchemaCommand().

◆ check_rolespec_name()

void check_rolespec_name ( const RoleSpec role,
const char *  detail_msg 
)

Definition at line 5493 of file acl.c.

5494 {
5495  if (!role)
5496  return;
5497 
5498  if (role->roletype != ROLESPEC_CSTRING)
5499  return;
5500 
5501  if (IsReservedName(role->rolename))
5502  {
5503  if (detail_msg)
5504  ereport(ERROR,
5505  (errcode(ERRCODE_RESERVED_NAME),
5506  errmsg("role name \"%s\" is reserved",
5507  role->rolename),
5508  errdetail_internal("%s", detail_msg)));
5509  else
5510  ereport(ERROR,
5511  (errcode(ERRCODE_RESERVED_NAME),
5512  errmsg("role name \"%s\" is reserved",
5513  role->rolename)));
5514  }
5515 }
bool IsReservedName(const char *name)
Definition: catalog.c:217
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1232
@ ROLESPEC_CSTRING
Definition: parsenodes.h:393
RoleSpecType roletype
Definition: parsenodes.h:403
char * rolename
Definition: parsenodes.h:404

References ereport, errcode(), errdetail_internal(), errmsg(), ERROR, IsReservedName(), RoleSpec::rolename, ROLESPEC_CSTRING, and RoleSpec::roletype.

Referenced by AlterRole(), and AlterRoleSet().

◆ ExecAlterDefaultPrivilegesStmt()

void ExecAlterDefaultPrivilegesStmt ( ParseState pstate,
AlterDefaultPrivilegesStmt stmt 
)

Definition at line 975 of file aclchk.c.

976 {
977  GrantStmt *action = stmt->action;
978  InternalDefaultACL iacls;
979  ListCell *cell;
980  List *rolespecs = NIL;
981  List *nspnames = NIL;
982  DefElem *drolespecs = NULL;
983  DefElem *dnspnames = NULL;
984  AclMode all_privileges;
985  const char *errormsg;
986 
987  /* Deconstruct the "options" part of the statement */
988  foreach(cell, stmt->options)
989  {
990  DefElem *defel = (DefElem *) lfirst(cell);
991 
992  if (strcmp(defel->defname, "schemas") == 0)
993  {
994  if (dnspnames)
995  errorConflictingDefElem(defel, pstate);
996  dnspnames = defel;
997  }
998  else if (strcmp(defel->defname, "roles") == 0)
999  {
1000  if (drolespecs)
1001  errorConflictingDefElem(defel, pstate);
1002  drolespecs = defel;
1003  }
1004  else
1005  elog(ERROR, "option \"%s\" not recognized", defel->defname);
1006  }
1007 
1008  if (dnspnames)
1009  nspnames = (List *) dnspnames->arg;
1010  if (drolespecs)
1011  rolespecs = (List *) drolespecs->arg;
1012 
1013  /* Prepare the InternalDefaultACL representation of the statement */
1014  /* roleid to be filled below */
1015  /* nspid to be filled in SetDefaultACLsInSchemas */
1016  iacls.is_grant = action->is_grant;
1017  iacls.objtype = action->objtype;
1018  /* all_privs to be filled below */
1019  /* privileges to be filled below */
1020  iacls.grantees = NIL; /* filled below */
1021  iacls.grant_option = action->grant_option;
1022  iacls.behavior = action->behavior;
1023 
1024  /*
1025  * Convert the RoleSpec list into an Oid list. Note that at this point we
1026  * insert an ACL_ID_PUBLIC into the list if appropriate, so downstream
1027  * there shouldn't be any additional work needed to support this case.
1028  */
1029  foreach(cell, action->grantees)
1030  {
1031  RoleSpec *grantee = (RoleSpec *) lfirst(cell);
1032  Oid grantee_uid;
1033 
1034  switch (grantee->roletype)
1035  {
1036  case ROLESPEC_PUBLIC:
1037  grantee_uid = ACL_ID_PUBLIC;
1038  break;
1039  default:
1040  grantee_uid = get_rolespec_oid(grantee, false);
1041  break;
1042  }
1043  iacls.grantees = lappend_oid(iacls.grantees, grantee_uid);
1044  }
1045 
1046  /*
1047  * Convert action->privileges, a list of privilege strings, into an
1048  * AclMode bitmask.
1049  */
1050  switch (action->objtype)
1051  {
1052  case OBJECT_TABLE:
1053  all_privileges = ACL_ALL_RIGHTS_RELATION;
1054  errormsg = gettext_noop("invalid privilege type %s for relation");
1055  break;
1056  case OBJECT_SEQUENCE:
1057  all_privileges = ACL_ALL_RIGHTS_SEQUENCE;
1058  errormsg = gettext_noop("invalid privilege type %s for sequence");
1059  break;
1060  case OBJECT_FUNCTION:
1061  all_privileges = ACL_ALL_RIGHTS_FUNCTION;
1062  errormsg = gettext_noop("invalid privilege type %s for function");
1063  break;
1064  case OBJECT_PROCEDURE:
1065  all_privileges = ACL_ALL_RIGHTS_FUNCTION;
1066  errormsg = gettext_noop("invalid privilege type %s for procedure");
1067  break;
1068  case OBJECT_ROUTINE:
1069  all_privileges = ACL_ALL_RIGHTS_FUNCTION;
1070  errormsg = gettext_noop("invalid privilege type %s for routine");
1071  break;
1072  case OBJECT_TYPE:
1073  all_privileges = ACL_ALL_RIGHTS_TYPE;
1074  errormsg = gettext_noop("invalid privilege type %s for type");
1075  break;
1076  case OBJECT_SCHEMA:
1077  all_privileges = ACL_ALL_RIGHTS_SCHEMA;
1078  errormsg = gettext_noop("invalid privilege type %s for schema");
1079  break;
1080  default:
1081  elog(ERROR, "unrecognized GrantStmt.objtype: %d",
1082  (int) action->objtype);
1083  /* keep compiler quiet */
1084  all_privileges = ACL_NO_RIGHTS;
1085  errormsg = NULL;
1086  }
1087 
1088  if (action->privileges == NIL)
1089  {
1090  iacls.all_privs = true;
1091 
1092  /*
1093  * will be turned into ACL_ALL_RIGHTS_* by the internal routines
1094  * depending on the object type
1095  */
1096  iacls.privileges = ACL_NO_RIGHTS;
1097  }
1098  else
1099  {
1100  iacls.all_privs = false;
1101  iacls.privileges = ACL_NO_RIGHTS;
1102 
1103  foreach(cell, action->privileges)
1104  {
1105  AccessPriv *privnode = (AccessPriv *) lfirst(cell);
1106  AclMode priv;
1107 
1108  if (privnode->cols)
1109  ereport(ERROR,
1110  (errcode(ERRCODE_INVALID_GRANT_OPERATION),
1111  errmsg("default privileges cannot be set for columns")));
1112 
1113  if (privnode->priv_name == NULL) /* parser mistake? */
1114  elog(ERROR, "AccessPriv node must specify privilege");
1115  priv = string_to_privilege(privnode->priv_name);
1116 
1117  if (priv & ~((AclMode) all_privileges))
1118  ereport(ERROR,
1119  (errcode(ERRCODE_INVALID_GRANT_OPERATION),
1120  errmsg(errormsg, privilege_to_string(priv))));
1121 
1122  iacls.privileges |= priv;
1123  }
1124  }
1125 
1126  if (rolespecs == NIL)
1127  {
1128  /* Set permissions for myself */
1129  iacls.roleid = GetUserId();
1130 
1131  SetDefaultACLsInSchemas(&iacls, nspnames);
1132  }
1133  else
1134  {
1135  /* Look up the role OIDs and do permissions checks */
1136  ListCell *rolecell;
1137 
1138  foreach(rolecell, rolespecs)
1139  {
1140  RoleSpec *rolespec = lfirst(rolecell);
1141 
1142  iacls.roleid = get_rolespec_oid(rolespec, false);
1143 
1144  if (!has_privs_of_role(GetUserId(), iacls.roleid))
1145  ereport(ERROR,
1146  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1147  errmsg("permission denied to change default privileges")));
1148 
1149  SetDefaultACLsInSchemas(&iacls, nspnames);
1150  }
1151  }
1152 }
Oid get_rolespec_oid(const RoleSpec *role, bool missing_ok)
Definition: acl.c:5386
static AclMode string_to_privilege(const char *privname)
Definition: aclchk.c:2598
static void SetDefaultACLsInSchemas(InternalDefaultACL *iacls, List *nspnames)
Definition: aclchk.c:1160
static const char * privilege_to_string(AclMode privilege)
Definition: aclchk.c:2641
void errorConflictingDefElem(DefElem *defel, ParseState *pstate)
Definition: define.c:384
#define stmt
Definition: indent_codes.h:59
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
Oid GetUserId(void)
Definition: miscinit.c:514
@ ROLESPEC_PUBLIC
Definition: parsenodes.h:397
#define lfirst(lc)
Definition: pg_list.h:172
#define NIL
Definition: pg_list.h:68
char * priv_name
Definition: parsenodes.h:2394
List * cols
Definition: parsenodes.h:2395
char * defname
Definition: parsenodes.h:811
Node * arg
Definition: parsenodes.h:812
AclMode privileges
Definition: aclchk.c:98
List * grantees
Definition: aclchk.c:99
DropBehavior behavior
Definition: aclchk.c:101
ObjectType objtype
Definition: aclchk.c:96
Definition: pg_list.h:54

References ACL_ALL_RIGHTS_FUNCTION, ACL_ALL_RIGHTS_RELATION, ACL_ALL_RIGHTS_SCHEMA, ACL_ALL_RIGHTS_SEQUENCE, ACL_ALL_RIGHTS_TYPE, ACL_ID_PUBLIC, ACL_NO_RIGHTS, generate_unaccent_rules::action, InternalDefaultACL::all_privs, DefElem::arg, InternalDefaultACL::behavior, AccessPriv::cols, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), get_rolespec_oid(), gettext_noop, GetUserId(), InternalDefaultACL::grant_option, InternalDefaultACL::grantees, has_privs_of_role(), if(), InternalDefaultACL::is_grant, lappend_oid(), lfirst, NIL, OBJECT_FUNCTION, OBJECT_PROCEDURE, OBJECT_ROUTINE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_TYPE, InternalDefaultACL::objtype, AccessPriv::priv_name, privilege_to_string(), InternalDefaultACL::privileges, InternalDefaultACL::roleid, ROLESPEC_PUBLIC, RoleSpec::roletype, SetDefaultACLsInSchemas(), stmt, and string_to_privilege().

Referenced by ProcessUtilitySlow().

◆ ExecuteGrantStmt()

void ExecuteGrantStmt ( GrantStmt stmt)

Definition at line 391 of file aclchk.c.

392 {
393  InternalGrant istmt;
394  ListCell *cell;
395  const char *errormsg;
396  AclMode all_privileges;
397 
398  if (stmt->grantor)
399  {
400  Oid grantor;
401 
402  grantor = get_rolespec_oid(stmt->grantor, false);
403 
404  /*
405  * Currently, this clause is only for SQL compatibility, not very
406  * interesting otherwise.
407  */
408  if (grantor != GetUserId())
409  ereport(ERROR,
410  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
411  errmsg("grantor must be current user")));
412  }
413 
414  /*
415  * Turn the regular GrantStmt into the InternalGrant form.
416  */
417  istmt.is_grant = stmt->is_grant;
418  istmt.objtype = stmt->objtype;
419 
420  /* Collect the OIDs of the target objects */
421  switch (stmt->targtype)
422  {
423  case ACL_TARGET_OBJECT:
424  istmt.objects = objectNamesToOids(stmt->objtype, stmt->objects,
425  stmt->is_grant);
426  break;
428  istmt.objects = objectsInSchemaToOids(stmt->objtype, stmt->objects);
429  break;
430  /* ACL_TARGET_DEFAULTS should not be seen here */
431  default:
432  elog(ERROR, "unrecognized GrantStmt.targtype: %d",
433  (int) stmt->targtype);
434  }
435 
436  /* all_privs to be filled below */
437  /* privileges to be filled below */
438  istmt.col_privs = NIL; /* may get filled below */
439  istmt.grantees = NIL; /* filled below */
440  istmt.grant_option = stmt->grant_option;
441  istmt.behavior = stmt->behavior;
442 
443  /*
444  * Convert the RoleSpec list into an Oid list. Note that at this point we
445  * insert an ACL_ID_PUBLIC into the list if appropriate, so downstream
446  * there shouldn't be any additional work needed to support this case.
447  */
448  foreach(cell, stmt->grantees)
449  {
450  RoleSpec *grantee = (RoleSpec *) lfirst(cell);
451  Oid grantee_uid;
452 
453  switch (grantee->roletype)
454  {
455  case ROLESPEC_PUBLIC:
456  grantee_uid = ACL_ID_PUBLIC;
457  break;
458  default:
459  grantee_uid = get_rolespec_oid(grantee, false);
460  break;
461  }
462  istmt.grantees = lappend_oid(istmt.grantees, grantee_uid);
463  }
464 
465  /*
466  * Convert stmt->privileges, a list of AccessPriv nodes, into an AclMode
467  * bitmask. Note: objtype can't be OBJECT_COLUMN.
468  */
469  switch (stmt->objtype)
470  {
471  case OBJECT_TABLE:
472 
473  /*
474  * Because this might be a sequence, we test both relation and
475  * sequence bits, and later do a more limited test when we know
476  * the object type.
477  */
479  errormsg = gettext_noop("invalid privilege type %s for relation");
480  break;
481  case OBJECT_SEQUENCE:
482  all_privileges = ACL_ALL_RIGHTS_SEQUENCE;
483  errormsg = gettext_noop("invalid privilege type %s for sequence");
484  break;
485  case OBJECT_DATABASE:
486  all_privileges = ACL_ALL_RIGHTS_DATABASE;
487  errormsg = gettext_noop("invalid privilege type %s for database");
488  break;
489  case OBJECT_DOMAIN:
490  all_privileges = ACL_ALL_RIGHTS_TYPE;
491  errormsg = gettext_noop("invalid privilege type %s for domain");
492  break;
493  case OBJECT_FUNCTION:
494  all_privileges = ACL_ALL_RIGHTS_FUNCTION;
495  errormsg = gettext_noop("invalid privilege type %s for function");
496  break;
497  case OBJECT_LANGUAGE:
498  all_privileges = ACL_ALL_RIGHTS_LANGUAGE;
499  errormsg = gettext_noop("invalid privilege type %s for language");
500  break;
501  case OBJECT_LARGEOBJECT:
502  all_privileges = ACL_ALL_RIGHTS_LARGEOBJECT;
503  errormsg = gettext_noop("invalid privilege type %s for large object");
504  break;
505  case OBJECT_SCHEMA:
506  all_privileges = ACL_ALL_RIGHTS_SCHEMA;
507  errormsg = gettext_noop("invalid privilege type %s for schema");
508  break;
509  case OBJECT_PROCEDURE:
510  all_privileges = ACL_ALL_RIGHTS_FUNCTION;
511  errormsg = gettext_noop("invalid privilege type %s for procedure");
512  break;
513  case OBJECT_ROUTINE:
514  all_privileges = ACL_ALL_RIGHTS_FUNCTION;
515  errormsg = gettext_noop("invalid privilege type %s for routine");
516  break;
517  case OBJECT_TABLESPACE:
518  all_privileges = ACL_ALL_RIGHTS_TABLESPACE;
519  errormsg = gettext_noop("invalid privilege type %s for tablespace");
520  break;
521  case OBJECT_TYPE:
522  all_privileges = ACL_ALL_RIGHTS_TYPE;
523  errormsg = gettext_noop("invalid privilege type %s for type");
524  break;
525  case OBJECT_FDW:
526  all_privileges = ACL_ALL_RIGHTS_FDW;
527  errormsg = gettext_noop("invalid privilege type %s for foreign-data wrapper");
528  break;
530  all_privileges = ACL_ALL_RIGHTS_FOREIGN_SERVER;
531  errormsg = gettext_noop("invalid privilege type %s for foreign server");
532  break;
534  all_privileges = ACL_ALL_RIGHTS_PARAMETER_ACL;
535  errormsg = gettext_noop("invalid privilege type %s for parameter");
536  break;
537  default:
538  elog(ERROR, "unrecognized GrantStmt.objtype: %d",
539  (int) stmt->objtype);
540  /* keep compiler quiet */
541  all_privileges = ACL_NO_RIGHTS;
542  errormsg = NULL;
543  }
544 
545  if (stmt->privileges == NIL)
546  {
547  istmt.all_privs = true;
548 
549  /*
550  * will be turned into ACL_ALL_RIGHTS_* by the internal routines
551  * depending on the object type
552  */
553  istmt.privileges = ACL_NO_RIGHTS;
554  }
555  else
556  {
557  istmt.all_privs = false;
558  istmt.privileges = ACL_NO_RIGHTS;
559 
560  foreach(cell, stmt->privileges)
561  {
562  AccessPriv *privnode = (AccessPriv *) lfirst(cell);
563  AclMode priv;
564 
565  /*
566  * If it's a column-level specification, we just set it aside in
567  * col_privs for the moment; but insist it's for a relation.
568  */
569  if (privnode->cols)
570  {
571  if (stmt->objtype != OBJECT_TABLE)
572  ereport(ERROR,
573  (errcode(ERRCODE_INVALID_GRANT_OPERATION),
574  errmsg("column privileges are only valid for relations")));
575  istmt.col_privs = lappend(istmt.col_privs, privnode);
576  continue;
577  }
578 
579  if (privnode->priv_name == NULL) /* parser mistake? */
580  elog(ERROR, "AccessPriv node must specify privilege or columns");
581  priv = string_to_privilege(privnode->priv_name);
582 
583  if (priv & ~((AclMode) all_privileges))
584  ereport(ERROR,
585  (errcode(ERRCODE_INVALID_GRANT_OPERATION),
586  errmsg(errormsg, privilege_to_string(priv))));
587 
588  istmt.privileges |= priv;
589  }
590  }
591 
592  ExecGrantStmt_oids(&istmt);
593 }
static void ExecGrantStmt_oids(InternalGrant *istmt)
Definition: aclchk.c:601
static List * objectNamesToOids(ObjectType objtype, List *objnames, bool is_grant)
Definition: aclchk.c:668
static List * objectsInSchemaToOids(ObjectType objtype, List *nspnames)
Definition: aclchk.c:848
List * lappend(List *list, void *datum)
Definition: list.c:339
@ ACL_TARGET_OBJECT
Definition: parsenodes.h:2337
@ ACL_TARGET_ALL_IN_SCHEMA
Definition: parsenodes.h:2338
DropBehavior behavior
AclMode privileges
ObjectType objtype

References ACL_ALL_RIGHTS_DATABASE, ACL_ALL_RIGHTS_FDW, ACL_ALL_RIGHTS_FOREIGN_SERVER, ACL_ALL_RIGHTS_FUNCTION, ACL_ALL_RIGHTS_LANGUAGE, ACL_ALL_RIGHTS_LARGEOBJECT, ACL_ALL_RIGHTS_PARAMETER_ACL, ACL_ALL_RIGHTS_RELATION, ACL_ALL_RIGHTS_SCHEMA, ACL_ALL_RIGHTS_SEQUENCE, ACL_ALL_RIGHTS_TABLESPACE, ACL_ALL_RIGHTS_TYPE, ACL_ID_PUBLIC, ACL_NO_RIGHTS, ACL_TARGET_ALL_IN_SCHEMA, ACL_TARGET_OBJECT, InternalGrant::all_privs, InternalGrant::behavior, InternalGrant::col_privs, AccessPriv::cols, elog, ereport, errcode(), errmsg(), ERROR, ExecGrantStmt_oids(), get_rolespec_oid(), gettext_noop, GetUserId(), InternalGrant::grant_option, InternalGrant::grantees, InternalGrant::is_grant, lappend(), lappend_oid(), lfirst, NIL, OBJECT_DATABASE, OBJECT_DOMAIN, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FUNCTION, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_PARAMETER_ACL, OBJECT_PROCEDURE, OBJECT_ROUTINE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TYPE, objectNamesToOids(), InternalGrant::objects, objectsInSchemaToOids(), InternalGrant::objtype, AccessPriv::priv_name, privilege_to_string(), InternalGrant::privileges, ROLESPEC_PUBLIC, RoleSpec::roletype, stmt, and string_to_privilege().

Referenced by ProcessUtilitySlow(), and standard_ProcessUtility().

◆ get_role_oid()

Oid get_role_oid ( const char *  rolname,
bool  missing_ok 
)

Definition at line 5352 of file acl.c.

5353 {
5354  Oid oid;
5355 
5356  oid = GetSysCacheOid1(AUTHNAME, Anum_pg_authid_oid,
5358  if (!OidIsValid(oid) && !missing_ok)
5359  ereport(ERROR,
5360  (errcode(ERRCODE_UNDEFINED_OBJECT),
5361  errmsg("role \"%s\" does not exist", rolname)));
5362  return oid;
5363 }
#define OidIsValid(objectId)
Definition: c.h:762
NameData rolname
Definition: pg_authid.h:34
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
#define GetSysCacheOid1(cacheId, oidcol, key1)
Definition: syscache.h:104

References CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid1, OidIsValid, and rolname.

Referenced by aclparse(), check_hba(), check_ident_usermap(), createdb(), CreateRole(), get_object_address_unqualified(), get_role_oid_or_public(), get_rolespec_oid(), GrantRole(), is_member(), pg_has_role_id_name(), pg_has_role_name(), pg_has_role_name_id(), pg_has_role_name_name(), regrolein(), shell_check_detail(), and worker_spi_launch().

◆ get_role_oid_or_public()

◆ get_rolespec_name()

char* get_rolespec_name ( const RoleSpec role)

Definition at line 5471 of file acl.c.

5472 {
5473  HeapTuple tp;
5474  Form_pg_authid authForm;
5475  char *rolename;
5476 
5477  tp = get_rolespec_tuple(role);
5478  authForm = (Form_pg_authid) GETSTRUCT(tp);
5479  rolename = pstrdup(NameStr(authForm->rolname));
5480  ReleaseSysCache(tp);
5481 
5482  return rolename;
5483 }
HeapTuple get_rolespec_tuple(const RoleSpec *role)
Definition: acl.c:5425
#define NameStr(name)
Definition: c.h:733
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
char * pstrdup(const char *in)
Definition: mcxt.c:1683
FormData_pg_authid * Form_pg_authid
Definition: pg_authid.h:56
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266

References get_rolespec_tuple(), GETSTRUCT, NameStr, pstrdup(), and ReleaseSysCache().

Referenced by AddRoleMems(), and DelRoleMems().

◆ get_rolespec_oid()

Oid get_rolespec_oid ( const RoleSpec role,
bool  missing_ok 
)

Definition at line 5386 of file acl.c.

5387 {
5388  Oid oid;
5389 
5390  switch (role->roletype)
5391  {
5392  case ROLESPEC_CSTRING:
5393  Assert(role->rolename);
5394  oid = get_role_oid(role->rolename, missing_ok);
5395  break;
5396 
5397  case ROLESPEC_CURRENT_ROLE:
5398  case ROLESPEC_CURRENT_USER:
5399  oid = GetUserId();
5400  break;
5401 
5402  case ROLESPEC_SESSION_USER:
5403  oid = GetSessionUserId();
5404  break;
5405 
5406  case ROLESPEC_PUBLIC:
5407  ereport(ERROR,
5408  (errcode(ERRCODE_UNDEFINED_OBJECT),
5409  errmsg("role \"%s\" does not exist", "public")));
5410  oid = InvalidOid; /* make compiler happy */
5411  break;
5412 
5413  default:
5414  elog(ERROR, "unexpected role type %d", role->roletype);
5415  }
5416 
5417  return oid;
5418 }
Oid GetSessionUserId(void)
Definition: miscinit.c:548
@ ROLESPEC_CURRENT_USER
Definition: parsenodes.h:395
@ ROLESPEC_SESSION_USER
Definition: parsenodes.h:396
@ ROLESPEC_CURRENT_ROLE
Definition: parsenodes.h:394
#define InvalidOid
Definition: postgres_ext.h:36

References Assert(), elog, ereport, errcode(), errmsg(), ERROR, get_role_oid(), GetSessionUserId(), GetUserId(), InvalidOid, RoleSpec::rolename, ROLESPEC_CSTRING, ROLESPEC_CURRENT_ROLE, ROLESPEC_CURRENT_USER, ROLESPEC_PUBLIC, ROLESPEC_SESSION_USER, and RoleSpec::roletype.

Referenced by AlterUserMapping(), ATExecCmd(), CreateSchemaCommand(), CreateTableSpace(), CreateUserMapping(), ExecAlterDefaultPrivilegesStmt(), ExecAlterOwnerStmt(), ExecuteGrantStmt(), GrantRole(), policy_role_list_to_array(), ReassignOwnedObjects(), RemoveUserMapping(), and roleSpecsToIds().

◆ get_rolespec_tuple()

HeapTuple get_rolespec_tuple ( const RoleSpec role)

Definition at line 5425 of file acl.c.

5426 {
5427  HeapTuple tuple;
5428 
5429  switch (role->roletype)
5430  {
5431  case ROLESPEC_CSTRING:
5432  Assert(role->rolename);
5433  tuple = SearchSysCache1(AUTHNAME, CStringGetDatum(role->rolename));
5434  if (!HeapTupleIsValid(tuple))
5435  ereport(ERROR,
5436  (errcode(ERRCODE_UNDEFINED_OBJECT),
5437  errmsg("role \"%s\" does not exist", role->rolename)));
5438  break;
5439 
5440  case ROLESPEC_CURRENT_ROLE:
5441  case ROLESPEC_CURRENT_USER:
5442  tuple = SearchSysCache1(AUTHOID, ObjectIdGetDatum(GetUserId()));
5443  if (!HeapTupleIsValid(tuple))
5444  elog(ERROR, "cache lookup failed for role %u", GetUserId());
5445  break;
5446 
5447  case ROLESPEC_SESSION_USER:
5448  tuple = SearchSysCache1(AUTHOID, ObjectIdGetDatum(GetSessionUserId()));
5449  if (!HeapTupleIsValid(tuple))
5450  elog(ERROR, "cache lookup failed for role %u", GetSessionUserId());
5451  break;
5452 
5453  case ROLESPEC_PUBLIC:
5454  ereport(ERROR,
5455  (errcode(ERRCODE_UNDEFINED_OBJECT),
5456  errmsg("role \"%s\" does not exist", "public")));
5457  tuple = NULL; /* make compiler happy */
5458  break;
5459 
5460  default:
5461  elog(ERROR, "unexpected role type %d", role->roletype);
5462  }
5463 
5464  return tuple;
5465 }
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218

References Assert(), CStringGetDatum(), elog, ereport, errcode(), errmsg(), ERROR, GetSessionUserId(), GetUserId(), HeapTupleIsValid, ObjectIdGetDatum(), RoleSpec::rolename, ROLESPEC_CSTRING, ROLESPEC_CURRENT_ROLE, ROLESPEC_CURRENT_USER, ROLESPEC_PUBLIC, ROLESPEC_SESSION_USER, RoleSpec::roletype, and SearchSysCache1().

Referenced by AlterRole(), AlterRoleSet(), CreateRole(), and get_rolespec_name().

◆ get_user_default_acl()

Acl* get_user_default_acl ( ObjectType  objtype,
Oid  ownerId,
Oid  nsp_oid 
)

Definition at line 4289 of file aclchk.c.

4290 {
4291  Acl *result;
4292  Acl *glob_acl;
4293  Acl *schema_acl;
4294  Acl *def_acl;
4295  char defaclobjtype;
4296 
4297  /*
4298  * Use NULL during bootstrap, since pg_default_acl probably isn't there
4299  * yet.
4300  */
4302  return NULL;
4303 
4304  /* Check if object type is supported in pg_default_acl */
4305  switch (objtype)
4306  {
4307  case OBJECT_TABLE:
4308  defaclobjtype = DEFACLOBJ_RELATION;
4309  break;
4310 
4311  case OBJECT_SEQUENCE:
4312  defaclobjtype = DEFACLOBJ_SEQUENCE;
4313  break;
4314 
4315  case OBJECT_FUNCTION:
4316  defaclobjtype = DEFACLOBJ_FUNCTION;
4317  break;
4318 
4319  case OBJECT_TYPE:
4320  defaclobjtype = DEFACLOBJ_TYPE;
4321  break;
4322 
4323  case OBJECT_SCHEMA:
4324  defaclobjtype = DEFACLOBJ_NAMESPACE;
4325  break;
4326 
4327  default:
4328  return NULL;
4329  }
4330 
4331  /* Look up the relevant pg_default_acl entries */
4332  glob_acl = get_default_acl_internal(ownerId, InvalidOid, defaclobjtype);
4333  schema_acl = get_default_acl_internal(ownerId, nsp_oid, defaclobjtype);
4334 
4335  /* Quick out if neither entry exists */
4336  if (glob_acl == NULL && schema_acl == NULL)
4337  return NULL;
4338 
4339  /* We need to know the hard-wired default value, too */
4340  def_acl = acldefault(objtype, ownerId);
4341 
4342  /* If there's no global entry, substitute the hard-wired default */
4343  if (glob_acl == NULL)
4344  glob_acl = def_acl;
4345 
4346  /* Merge in any per-schema privileges */
4347  result = aclmerge(glob_acl, schema_acl, ownerId);
4348 
4349  /*
4350  * For efficiency, we want to return NULL if the result equals default.
4351  * This requires sorting both arrays to get an accurate comparison.
4352  */
4353  aclitemsort(result);
4354  aclitemsort(def_acl);
4355  if (aclequal(result, def_acl))
4356  result = NULL;
4357 
4358  return result;
4359 }
bool aclequal(const Acl *left_acl, const Acl *right_acl)
Definition: acl.c:534
void aclitemsort(Acl *acl)
Definition: acl.c:520
Acl * acldefault(ObjectType objtype, Oid ownerId)
Definition: acl.c:778
Acl * aclmerge(const Acl *left_acl, const Acl *right_acl, Oid ownerId)
Definition: acl.c:476
static Acl * get_default_acl_internal(Oid roleId, Oid nsp_oid, char objtype)
Definition: aclchk.c:4254
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:451

References acldefault(), aclequal(), aclitemsort(), aclmerge(), get_default_acl_internal(), InvalidOid, IsBootstrapProcessingMode, OBJECT_FUNCTION, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_TABLE, and OBJECT_TYPE.

Referenced by heap_create_with_catalog(), NamespaceCreate(), ProcedureCreate(), and TypeCreate().

◆ has_bypassrls_privilege()

bool has_bypassrls_privilege ( Oid  roleid)

Definition at line 4230 of file aclchk.c.

4231 {
4232  bool result = false;
4233  HeapTuple utup;
4234 
4235  /* Superusers bypass all permission checking. */
4236  if (superuser_arg(roleid))
4237  return true;
4238 
4239  utup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
4240  if (HeapTupleIsValid(utup))
4241  {
4242  result = ((Form_pg_authid) GETSTRUCT(utup))->rolbypassrls;
4243  ReleaseSysCache(utup);
4244  }
4245  return result;
4246 }
bool rolbypassrls
Definition: pg_authid.h:41
bool superuser_arg(Oid roleid)
Definition: superuser.c:56

References GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), rolbypassrls, SearchSysCache1(), and superuser_arg().

Referenced by AlterRole(), check_enable_rls(), CreateRole(), and RI_Initial_Check().

◆ has_createrole_privilege()

bool has_createrole_privilege ( Oid  roleid)

Definition at line 4211 of file aclchk.c.

4212 {
4213  bool result = false;
4214  HeapTuple utup;
4215 
4216  /* Superusers bypass all permission checking. */
4217  if (superuser_arg(roleid))
4218  return true;
4219 
4220  utup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
4221  if (HeapTupleIsValid(utup))
4222  {
4223  result = ((Form_pg_authid) GETSTRUCT(utup))->rolcreaterole;
4224  ReleaseSysCache(utup);
4225  }
4226  return result;
4227 }
bool rolcreaterole
Definition: pg_authid.h:37

References GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), rolcreaterole, SearchSysCache1(), and superuser_arg().

Referenced by check_object_ownership(), CreateRole(), and have_createrole_privilege().

◆ has_privs_of_role()

bool has_privs_of_role ( Oid  member,
Oid  role 
)

Definition at line 5066 of file acl.c.

5067 {
5068  /* Fast path for simple case */
5069  if (member == role)
5070  return true;
5071 
5072  /* Superusers have every privilege, so are part of every role */
5073  if (superuser_arg(member))
5074  return true;
5075 
5076  /*
5077  * Find all the roles that member has the privileges of, including
5078  * multi-level recursion, then see if target role is any one of them.
5079  */
5081  InvalidOid, NULL),
5082  role);
5083 }
@ ROLERECURSE_PRIVS
Definition: acl.c:74
static List * roles_is_member_of(Oid roleid, enum RoleRecurseType type, Oid admin_of, Oid *admin_role)
Definition: acl.c:4941
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:722

References InvalidOid, list_member_oid(), ROLERECURSE_PRIVS, roles_is_member_of(), and superuser_arg().

Referenced by aclmask(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), bbsink_server_new(), calculate_database_size(), calculate_tablespace_size(), check_role_for_policy(), check_role_grantor(), ConfigOptionIsVisible(), convert_and_check_filename(), CreateSubscription(), DoCopy(), DropOwnedObjects(), ExecAlterDefaultPrivilegesStmt(), file_fdw_validator(), GetConfigOptionValues(), InitPostgres(), object_ownercheck(), pg_class_aclmask_ext(), pg_namespace_aclmask_ext(), pg_role_aclcheck(), pg_signal_backend(), pg_stat_get_wal_receiver(), pg_stat_get_wal_senders(), pg_stat_statements_internal(), pgrowlocks(), ReassignOwnedObjects(), ReindexMultipleTables(), shell_check_detail(), standard_ProcessUtility(), and TerminateOtherDBBackends().

◆ initialize_acl()

void initialize_acl ( void  )

Definition at line 4876 of file acl.c.

4877 {
4879  {
4880  cached_db_hash =
4881  GetSysCacheHashValue1(DATABASEOID,
4883 
4884  /*
4885  * In normal mode, set a callback on any syscache invalidation of rows
4886  * of pg_auth_members (for roles_is_member_of()) pg_database (for
4887  * roles_is_member_of())
4888  */
4889  CacheRegisterSyscacheCallback(AUTHMEMROLEMEM,
4891  (Datum) 0);
4894  (Datum) 0);
4895  CacheRegisterSyscacheCallback(DATABASEOID,
4897  (Datum) 0);
4898  }
4899 }
static uint32 cached_db_hash
Definition: acl.c:79
static void RoleMembershipCacheCallback(Datum arg, int cacheid, uint32 hashvalue)
Definition: acl.c:4906
Oid MyDatabaseId
Definition: globals.c:91
void CacheRegisterSyscacheCallback(int cacheid, SyscacheCallbackFunction func, Datum arg)
Definition: inval.c:1516
uintptr_t Datum
Definition: postgres.h:64
#define GetSysCacheHashValue1(cacheId, key1)
Definition: syscache.h:113

References cached_db_hash, CacheRegisterSyscacheCallback(), GetSysCacheHashValue1, IsBootstrapProcessingMode, MyDatabaseId, ObjectIdGetDatum(), and RoleMembershipCacheCallback().

Referenced by InitPostgres().

◆ is_admin_of_role()

bool is_admin_of_role ( Oid  member,
Oid  role 
)

Definition at line 5196 of file acl.c.

5197 {
5198  Oid admin_role;
5199 
5200  if (superuser_arg(member))
5201  return true;
5202 
5203  /* By policy, a role cannot have WITH ADMIN OPTION on itself. */
5204  if (member == role)
5205  return false;
5206 
5207  (void) roles_is_member_of(member, ROLERECURSE_MEMBERS, role, &admin_role);
5208  return OidIsValid(admin_role);
5209 }
@ ROLERECURSE_MEMBERS
Definition: acl.c:73

References OidIsValid, ROLERECURSE_MEMBERS, roles_is_member_of(), and superuser_arg().

Referenced by AlterRole(), AlterRoleSet(), check_object_ownership(), check_role_membership_authorization(), DropRole(), pg_role_aclcheck(), and RenameRole().

◆ is_member_of_role()

bool is_member_of_role ( Oid  member,
Oid  role 
)

Definition at line 5146 of file acl.c.

5147 {
5148  /* Fast path for simple case */
5149  if (member == role)
5150  return true;
5151 
5152  /* Superusers have every privilege, so are part of every role */
5153  if (superuser_arg(member))
5154  return true;
5155 
5156  /*
5157  * Find all the roles that member is a member of, including multi-level
5158  * recursion, then see if target role is any one of them.
5159  */
5161  InvalidOid, NULL),
5162  role);
5163 }

References InvalidOid, list_member_oid(), ROLERECURSE_MEMBERS, roles_is_member_of(), and superuser_arg().

Referenced by pg_role_aclcheck().

◆ is_member_of_role_nosuper()

bool is_member_of_role_nosuper ( Oid  member,
Oid  role 
)

Definition at line 5174 of file acl.c.

5175 {
5176  /* Fast path for simple case */
5177  if (member == role)
5178  return true;
5179 
5180  /*
5181  * Find all the roles that member is a member of, including multi-level
5182  * recursion, then see if target role is any one of them.
5183  */
5185  InvalidOid, NULL),
5186  role);
5187 }

References InvalidOid, list_member_oid(), ROLERECURSE_MEMBERS, and roles_is_member_of().

Referenced by AddRoleMems(), and is_member().

◆ make_empty_acl()

Acl* make_empty_acl ( void  )

Definition at line 423 of file acl.c.

424 {
425  return allocacl(0);
426 }

References allocacl().

Referenced by SetDefaultACL().

◆ member_can_set_role()

bool member_can_set_role ( Oid  member,
Oid  role 
)

Definition at line 5100 of file acl.c.

5101 {
5102  /* Fast path for simple case */
5103  if (member == role)
5104  return true;
5105 
5106  /* Superusers have every privilege, so can always SET ROLE */
5107  if (superuser_arg(member))
5108  return true;
5109 
5110  /*
5111  * Find all the roles that member can access via SET ROLE, including
5112  * multi-level recursion, then see if target role is any one of them.
5113  */
5115  InvalidOid, NULL),
5116  role);
5117 }
@ ROLERECURSE_SETROLE
Definition: acl.c:75

References InvalidOid, list_member_oid(), ROLERECURSE_SETROLE, roles_is_member_of(), and superuser_arg().

Referenced by check_can_set_role(), check_role(), pg_role_aclcheck(), and SwitchToUntrustedUser().

◆ object_aclcheck()

AclResult object_aclcheck ( Oid  classid,
Oid  objectid,
Oid  roleid,
AclMode  mode 
)

Definition at line 3876 of file aclchk.c.

3877 {
3878  return object_aclcheck_ext(classid, objectid, roleid, mode, NULL);
3879 }
AclResult object_aclcheck_ext(Oid classid, Oid objectid, Oid roleid, AclMode mode, bool *is_missing)
Definition: aclchk.c:3886
static PgChecksumMode mode
Definition: pg_checksums.c:56

References mode, and object_aclcheck_ext().

Referenced by AggregateCreate(), AlterExtensionNamespace(), AlterForeignServerOwner_internal(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), AlterPublicationOwner_internal(), AlterSchemaOwner_internal(), AlterSubscriptionOwner_internal(), AlterTableMoveAll(), AlterTypeOwner(), ATExecChangeOwner(), ATPrepAlterColumnType(), ATPrepSetTableSpace(), BuildDescForRelation(), calculate_database_size(), calculate_tablespace_size(), call_pltcl_start_proc(), check_temp_tablespaces(), CheckFunctionValidatorAccess(), CheckMyDatabase(), compute_return_type(), CreateCast(), CreateConversionCommand(), createdb(), CreateForeignServer(), CreateForeignTable(), CreateFunction(), CreatePublication(), CreateSchemaCommand(), CreateSubscription(), CreateTransform(), CreateTriggerFiringOn(), DefineAggregate(), DefineCollation(), DefineDomain(), DefineEnum(), DefineIndex(), DefineOpClass(), DefineOperator(), DefineOpFamily(), DefineRange(), DefineRelation(), DefineTSConfiguration(), DefineTSDictionary(), DefineType(), ExecBuildGroupingEqual(), ExecBuildParamSetEqual(), ExecInitAgg(), ExecInitExprRec(), ExecInitFunc(), ExecInitWindowAgg(), ExecReindex(), ExecuteCallStmt(), ExecuteDoStmt(), extension_is_trusted(), findRangeCanonicalFunction(), findRangeSubtypeDiffFunction(), get_connect_string(), get_other_operator(), HandleFunctionRequest(), has_database_privilege_id_name(), has_database_privilege_name(), has_database_privilege_name_name(), has_foreign_data_wrapper_privilege_id_name(), has_foreign_data_wrapper_privilege_name(), has_foreign_data_wrapper_privilege_name_name(), has_function_privilege_id_name(), has_function_privilege_name(), has_function_privilege_name_name(), has_language_privilege_id_name(), has_language_privilege_name(), has_language_privilege_name_name(), has_schema_privilege_id_name(), has_schema_privilege_name(), has_schema_privilege_name_name(), has_server_privilege_id_name(), has_server_privilege_name(), has_server_privilege_name_name(), has_tablespace_privilege_id_name(), has_tablespace_privilege_name(), has_tablespace_privilege_name_name(), has_type_privilege_id_name(), has_type_privilege_name(), has_type_privilege_name_name(), ImportForeignSchema(), init_sexpr(), initialize_peragg(), InitTempTableNamespace(), inline_function(), inline_set_returning_function(), interpret_function_parameter_list(), lookup_agg_function(), LookupCreationNamespace(), LookupExplicitNamespace(), movedb(), PrepareTempTablespaces(), preprocessNamespacePath(), RangeVarCallbackForAlterRelation(), RangeVarGetAndCheckCreationNamespace(), ReindexMultipleInternal(), RenameSchema(), transformTableLikeClause(), user_mapping_ddl_aclcheck(), ValidateJoinEstimator(), and ValidateRestrictionEstimator().

◆ object_aclcheck_ext()

◆ object_ownercheck()

bool object_ownercheck ( Oid  classid,
Oid  objectid,
Oid  roleid 
)

Definition at line 4130 of file aclchk.c.

4131 {
4132  int cacheid;
4133  Oid ownerId;
4134 
4135  /* Superusers bypass all permission checking. */
4136  if (superuser_arg(roleid))
4137  return true;
4138 
4139  /* For large objects, the catalog to consult is pg_largeobject_metadata */
4140  if (classid == LargeObjectRelationId)
4141  classid = LargeObjectMetadataRelationId;
4142 
4143  cacheid = get_object_catcache_oid(classid);
4144  if (cacheid != -1)
4145  {
4146  /* we can get the object's tuple from the syscache */
4147  HeapTuple tuple;
4148 
4149  tuple = SearchSysCache1(cacheid, ObjectIdGetDatum(objectid));
4150  if (!HeapTupleIsValid(tuple))
4151  ereport(ERROR,
4152  (errcode(ERRCODE_UNDEFINED_OBJECT),
4153  errmsg("%s with OID %u does not exist", get_object_class_descr(classid), objectid)));
4154 
4155  ownerId = DatumGetObjectId(SysCacheGetAttrNotNull(cacheid,
4156  tuple,
4157  get_object_attnum_owner(classid)));
4158  ReleaseSysCache(tuple);
4159  }
4160  else
4161  {
4162  /* for catalogs without an appropriate syscache */
4163  Relation rel;
4164  ScanKeyData entry[1];
4165  SysScanDesc scan;
4166  HeapTuple tuple;
4167  bool isnull;
4168 
4169  rel = table_open(classid, AccessShareLock);
4170 
4171  ScanKeyInit(&entry[0],
4172  get_object_attnum_oid(classid),
4173  BTEqualStrategyNumber, F_OIDEQ,
4174  ObjectIdGetDatum(objectid));
4175 
4176  scan = systable_beginscan(rel,
4177  get_object_oid_index(classid), true,
4178  NULL, 1, entry);
4179 
4180  tuple = systable_getnext(scan);
4181  if (!HeapTupleIsValid(tuple))
4182  ereport(ERROR,
4183  (errcode(ERRCODE_UNDEFINED_OBJECT),
4184  errmsg("%s with OID %u does not exist", get_object_class_descr(classid), objectid)));
4185 
4186  ownerId = DatumGetObjectId(heap_getattr(tuple,
4187  get_object_attnum_owner(classid),
4188  RelationGetDescr(rel),
4189  &isnull));
4190  Assert(!isnull);
4191 
4192  systable_endscan(scan);
4194  }
4195 
4196  return has_privs_of_role(roleid, ownerId);
4197 }
void systable_endscan(SysScanDesc sysscan)
Definition: genam.c:596
HeapTuple systable_getnext(SysScanDesc sysscan)
Definition: genam.c:503
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:384
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:792
#define AccessShareLock
Definition: lockdefs.h:36
AttrNumber get_object_attnum_owner(Oid class_id)
AttrNumber get_object_attnum_oid(Oid class_id)
int get_object_catcache_oid(Oid class_id)
Oid get_object_oid_index(Oid class_id)
const char * get_object_class_descr(Oid class_id)
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:242
#define RelationGetDescr(relation)
Definition: rel.h:531
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
#define BTEqualStrategyNumber
Definition: stratnum.h:31
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:510
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40

References AccessShareLock, Assert(), BTEqualStrategyNumber, DatumGetObjectId(), ereport, errcode(), errmsg(), ERROR, get_object_attnum_oid(), get_object_attnum_owner(), get_object_catcache_oid(), get_object_class_descr(), get_object_oid_index(), has_privs_of_role(), heap_getattr(), HeapTupleIsValid, ObjectIdGetDatum(), RelationGetDescr, ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), superuser_arg(), SysCacheGetAttrNotNull(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterCollation(), AlterDatabase(), AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterDatabaseSet(), AlterEventTrigger(), AlterEventTriggerOwner_internal(), AlterExtensionNamespace(), AlterForeignServer(), AlterForeignServerOwner_internal(), AlterFunction(), AlterOperator(), AlterOpFamilyAdd(), AlterPublication(), AlterPublicationOwner_internal(), AlterRoleSet(), AlterSchemaOwner_internal(), AlterStatistics(), AlterSubscription(), AlterSubscriptionOwner_internal(), AlterTableMoveAll(), AlterTableSpaceOptions(), AlterTSConfiguration(), AlterTSDictionary(), AlterType(), AlterTypeNamespace_oid(), AlterTypeOwner(), ATExecChangeOwner(), ATSimplePermissions(), be_lo_unlink(), brin_desummarize_range(), brin_summarize_range(), check_enable_rls(), check_object_ownership(), checkDomainOwner(), checkEnumOwner(), CreateCast(), createdb(), CreateProceduralLanguage(), CreateStatistics(), CreateTransform(), DefineOpClass(), DefineQueryRewrite(), DefineType(), dropdb(), DropSubscription(), DropTableSpace(), EnableDisableRule(), ExecAlterExtensionContentsStmt(), ExecAlterExtensionStmt(), ExecuteTruncateGuts(), gin_clean_pending_list(), heap_force_common(), MergeAttributes(), movedb(), OperatorCreate(), ProcedureCreate(), PublicationAddTables(), RangeVarCallbackForAlterRelation(), RangeVarCallbackForDropRelation(), RangeVarCallbackForPolicy(), RangeVarCallbackForRenameRule(), RangeVarCallbackForRenameTrigger(), RangeVarCallbackOwnsRelation(), RangeVarGetAndCheckCreationNamespace(), ReindexMultipleTables(), RemoveObjects(), renameatt_check(), RenameDatabase(), RenameSchema(), RenameTableSpace(), RenameType(), RI_Initial_Check(), user_mapping_ddl_aclcheck(), vacuum_is_permitted_for_relation(), and ValidateOperatorReference().

◆ pg_attribute_aclcheck()

AclResult pg_attribute_aclcheck ( Oid  table_oid,
AttrNumber  attnum,
Oid  roleid,
AclMode  mode 
)

Definition at line 3908 of file aclchk.c.

3910 {
3911  return pg_attribute_aclcheck_ext(table_oid, attnum, roleid, mode, NULL);
3912 }
AclResult pg_attribute_aclcheck_ext(Oid table_oid, AttrNumber attnum, Oid roleid, AclMode mode, bool *is_missing)
Definition: aclchk.c:3920
int16 attnum
Definition: pg_attribute.h:74

References attnum, mode, and pg_attribute_aclcheck_ext().

Referenced by BuildIndexValueDescription(), checkFkeyPermissions(), examine_simple_variable(), ExecBuildSlotPartitionKeyDescription(), ExecBuildSlotValueDescription(), ExecCheckOneRelPerms(), ExecCheckPermissionsModified(), ri_ReportViolation(), and statext_is_compatible_clause().

◆ pg_attribute_aclcheck_all()

AclResult pg_attribute_aclcheck_all ( Oid  table_oid,
Oid  roleid,
AclMode  mode,
AclMaskHow  how 
)

Definition at line 3950 of file aclchk.c.

3952 {
3953  return pg_attribute_aclcheck_all_ext(table_oid, roleid, mode, how, NULL);
3954 }
AclResult pg_attribute_aclcheck_all_ext(Oid table_oid, Oid roleid, AclMode mode, AclMaskHow how, bool *is_missing)
Definition: aclchk.c:3961

References mode, and pg_attribute_aclcheck_all_ext().

Referenced by ExecCheckOneRelPerms(), ExecCheckPermissionsModified(), has_any_column_privilege_id_name(), has_any_column_privilege_name(), has_any_column_privilege_name_name(), and statext_is_compatible_clause().

◆ pg_attribute_aclcheck_all_ext()

AclResult pg_attribute_aclcheck_all_ext ( Oid  table_oid,
Oid  roleid,
AclMode  mode,
AclMaskHow  how,
bool is_missing 
)

Definition at line 3961 of file aclchk.c.

3964 {
3965  AclResult result;
3966  HeapTuple classTuple;
3967  Form_pg_class classForm;
3968  Oid ownerId;
3969  AttrNumber nattrs;
3970  AttrNumber curr_att;
3971 
3972  /*
3973  * Must fetch pg_class row to get owner ID and number of attributes.
3974  */
3975  classTuple = SearchSysCache1(RELOID, ObjectIdGetDatum(table_oid));
3976  if (!HeapTupleIsValid(classTuple))
3977  {
3978  if (is_missing != NULL)
3979  {
3980  /* return "no privileges" instead of throwing an error */
3981  *is_missing = true;
3982  return ACLCHECK_NO_PRIV;
3983  }
3984  else
3985  ereport(ERROR,
3987  errmsg("relation with OID %u does not exist",
3988  table_oid)));
3989  }
3990  classForm = (Form_pg_class) GETSTRUCT(classTuple);
3991 
3992  ownerId = classForm->relowner;
3993  nattrs = classForm->relnatts;
3994 
3995  ReleaseSysCache(classTuple);
3996 
3997  /*
3998  * Initialize result in case there are no non-dropped columns. We want to
3999  * report failure in such cases for either value of 'how'.
4000  */
4001  result = ACLCHECK_NO_PRIV;
4002 
4003  for (curr_att = 1; curr_att <= nattrs; curr_att++)
4004  {
4005  HeapTuple attTuple;
4006  Datum aclDatum;
4007  bool isNull;
4008  Acl *acl;
4009  AclMode attmask;
4010 
4011  attTuple = SearchSysCache2(ATTNUM,
4012  ObjectIdGetDatum(table_oid),
4013  Int16GetDatum(curr_att));
4014 
4015  /*
4016  * Lookup failure probably indicates that the table was just dropped,
4017  * but we'll treat it the same as a dropped column rather than
4018  * throwing error.
4019  */
4020  if (!HeapTupleIsValid(attTuple))
4021  continue;
4022 
4023  /* ignore dropped columns */
4024  if (((Form_pg_attribute) GETSTRUCT(attTuple))->attisdropped)
4025  {
4026  ReleaseSysCache(attTuple);
4027  continue;
4028  }
4029 
4030  aclDatum = SysCacheGetAttr(ATTNUM, attTuple, Anum_pg_attribute_attacl,
4031  &isNull);
4032 
4033  /*
4034  * Here we hard-wire knowledge that the default ACL for a column
4035  * grants no privileges, so that we can fall out quickly in the very
4036  * common case where attacl is null.
4037  */
4038  if (isNull)
4039  attmask = 0;
4040  else
4041  {
4042  /* detoast column's ACL if necessary */
4043  acl = DatumGetAclP(aclDatum);
4044 
4045  attmask = aclmask(acl, roleid, ownerId, mode, ACLMASK_ANY);
4046 
4047  /* if we have a detoasted copy, free it */
4048  if ((Pointer) acl != DatumGetPointer(aclDatum))
4049  pfree(acl);
4050  }
4051 
4052  ReleaseSysCache(attTuple);
4053 
4054  if (attmask != 0)
4055  {
4056  result = ACLCHECK_OK;
4057  if (how == ACLMASK_ANY)
4058  break; /* succeed on any success */
4059  }
4060  else
4061  {
4062  result = ACLCHECK_NO_PRIV;
4063  if (how == ACLMASK_ALL)
4064  break; /* fail on any failure */
4065  }
4066  }
4067 
4068  return result;
4069 }
AclMode aclmask(const Acl *acl, Oid roleid, Oid ownerId, AclMode mask, AclMaskHow how)
Definition: acl.c:1357
#define DatumGetAclP(X)
Definition: acl.h:120
int16 AttrNumber
Definition: attnum.h:21
char * Pointer
Definition: c.h:470
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
#define ERRCODE_UNDEFINED_TABLE
Definition: pgbench.c:78
static Datum Int16GetDatum(int16 X)
Definition: postgres.h:172
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:479
HeapTuple SearchSysCache2(int cacheId, Datum key1, Datum key2)
Definition: syscache.c:229

References ACLCHECK_NO_PRIV, ACLCHECK_OK, aclmask(), ACLMASK_ALL, ACLMASK_ANY, DatumGetAclP, DatumGetPointer(), ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, Int16GetDatum(), mode, ObjectIdGetDatum(), pfree(), ReleaseSysCache(), SearchSysCache1(), SearchSysCache2(), and SysCacheGetAttr().

Referenced by has_any_column_privilege_id(), has_any_column_privilege_id_id(), has_any_column_privilege_name_id(), and pg_attribute_aclcheck_all().

◆ pg_attribute_aclcheck_ext()

AclResult pg_attribute_aclcheck_ext ( Oid  table_oid,
AttrNumber  attnum,
Oid  roleid,
AclMode  mode,
bool is_missing 
)

Definition at line 3920 of file aclchk.c.

3922 {
3923  if (pg_attribute_aclmask_ext(table_oid, attnum, roleid, mode,
3924  ACLMASK_ANY, is_missing) != 0)
3925  return ACLCHECK_OK;
3926  else
3927  return ACLCHECK_NO_PRIV;
3928 }
static AclMode pg_attribute_aclmask_ext(Oid table_oid, AttrNumber attnum, Oid roleid, AclMode mask, AclMaskHow how, bool *is_missing)
Definition: aclchk.c:3198

References ACLCHECK_NO_PRIV, ACLCHECK_OK, ACLMASK_ANY, attnum, mode, and pg_attribute_aclmask_ext().

Referenced by column_privilege_check(), and pg_attribute_aclcheck().

◆ pg_class_aclcheck()

◆ pg_class_aclcheck_ext()

AclResult pg_class_aclcheck_ext ( Oid  table_oid,
Oid  roleid,
AclMode  mode,
bool is_missing 
)

Definition at line 4089 of file aclchk.c.

4091 {
4092  if (pg_class_aclmask_ext(table_oid, roleid, mode,
4093  ACLMASK_ANY, is_missing) != 0)
4094  return ACLCHECK_OK;
4095  else
4096  return ACLCHECK_NO_PRIV;
4097 }
static AclMode pg_class_aclmask_ext(Oid table_oid, Oid roleid, AclMode mask, AclMaskHow how, bool *is_missing)
Definition: aclchk.c:3322

References ACLCHECK_NO_PRIV, ACLCHECK_OK, ACLMASK_ANY, mode, and pg_class_aclmask_ext().

Referenced by column_privilege_check(), has_any_column_privilege_id(), has_any_column_privilege_id_id(), has_any_column_privilege_name_id(), has_sequence_privilege_id(), has_sequence_privilege_id_id(), has_sequence_privilege_name_id(), has_table_privilege_id(), has_table_privilege_id_id(), has_table_privilege_name_id(), and pg_class_aclcheck().

◆ pg_class_aclmask()

AclMode pg_class_aclmask ( Oid  table_oid,
Oid  roleid,
AclMode  mask,
AclMaskHow  how 
)

Definition at line 3312 of file aclchk.c.

3314 {
3315  return pg_class_aclmask_ext(table_oid, roleid, mask, how, NULL);
3316 }

References pg_class_aclmask_ext().

Referenced by ExecCheckOneRelPerms(), and pg_aclmask().

◆ pg_largeobject_aclcheck_snapshot()

AclResult pg_largeobject_aclcheck_snapshot ( Oid  lobj_oid,
Oid  roleid,
AclMode  mode,
Snapshot  snapshot 
)

Definition at line 4116 of file aclchk.c.

4118 {
4119  if (pg_largeobject_aclmask_snapshot(lobj_oid, roleid, mode,
4120  ACLMASK_ANY, snapshot) != 0)
4121  return ACLCHECK_OK;
4122  else
4123  return ACLCHECK_NO_PRIV;
4124 }
static AclMode pg_largeobject_aclmask_snapshot(Oid lobj_oid, Oid roleid, AclMode mask, AclMaskHow how, Snapshot snapshot)
Definition: aclchk.c:3575

References ACLCHECK_NO_PRIV, ACLCHECK_OK, ACLMASK_ANY, mode, and pg_largeobject_aclmask_snapshot().

Referenced by be_lo_put(), and inv_open().

◆ pg_parameter_aclcheck()

AclResult pg_parameter_aclcheck ( const char *  name,
Oid  roleid,
AclMode  mode 
)

Definition at line 4104 of file aclchk.c.

4105 {
4106  if (pg_parameter_aclmask(name, roleid, mode, ACLMASK_ANY) != 0)
4107  return ACLCHECK_OK;
4108  else
4109  return ACLCHECK_NO_PRIV;
4110 }
static AclMode pg_parameter_aclmask(const char *name, Oid roleid, AclMode mask, AclMaskHow how)
Definition: aclchk.c:3452
const char * name

References ACLCHECK_NO_PRIV, ACLCHECK_OK, ACLMASK_ANY, mode, name, and pg_parameter_aclmask().

Referenced by AlterSystemSetConfigFile(), has_param_priv_byname(), set_config_with_handle(), and validate_option_array_item().

◆ recordDependencyOnNewAcl()

void recordDependencyOnNewAcl ( Oid  classId,
Oid  objectId,
int32  objsubId,
Oid  ownerId,
Acl acl 
)

Definition at line 4365 of file aclchk.c.

4367 {
4368  int nmembers;
4369  Oid *members;
4370 
4371  /* Nothing to do if ACL is defaulted */
4372  if (acl == NULL)
4373  return;
4374 
4375  /* Extract roles mentioned in ACL */
4376  nmembers = aclmembers(acl, &members);
4377 
4378  /* Update the shared dependency ACL info */
4379  updateAclDependencies(classId, objectId, objsubId,
4380  ownerId,
4381  0, NULL,
4382  nmembers, members);
4383 }
int aclmembers(const Acl *acl, Oid **roleids)
Definition: acl.c:1509
void updateAclDependencies(Oid classId, Oid objectId, int32 objsubId, Oid ownerId, int noldmembers, Oid *oldmembers, int nnewmembers, Oid *newmembers)
Definition: pg_shdepend.c:477

References aclmembers(), and updateAclDependencies().

Referenced by GenerateTypeDependencies(), heap_create_with_catalog(), NamespaceCreate(), and ProcedureCreate().

◆ recordExtObjInitPriv()

void recordExtObjInitPriv ( Oid  objoid,
Oid  classoid 
)

Definition at line 4392 of file aclchk.c.

4393 {
4394  /*
4395  * pg_class / pg_attribute
4396  *
4397  * If this is a relation then we need to see if there are any sub-objects
4398  * (eg: columns) for it and, if so, be sure to call
4399  * recordExtensionInitPrivWorker() for each one.
4400  */
4401  if (classoid == RelationRelationId)
4402  {
4403  Form_pg_class pg_class_tuple;
4404  Datum aclDatum;
4405  bool isNull;
4406  HeapTuple tuple;
4407 
4408  tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(objoid));
4409  if (!HeapTupleIsValid(tuple))
4410  elog(ERROR, "cache lookup failed for relation %u", objoid);
4411  pg_class_tuple = (Form_pg_class) GETSTRUCT(tuple);
4412 
4413  /*
4414  * Indexes don't have permissions, neither do the pg_class rows for
4415  * composite types. (These cases are unreachable given the
4416  * restrictions in ALTER EXTENSION ADD, but let's check anyway.)
4417  */
4418  if (pg_class_tuple->relkind == RELKIND_INDEX ||
4419  pg_class_tuple->relkind == RELKIND_PARTITIONED_INDEX ||
4420  pg_class_tuple->relkind == RELKIND_COMPOSITE_TYPE)
4421  {
4422  ReleaseSysCache(tuple);
4423  return;
4424  }
4425 
4426  /*
4427  * If this isn't a sequence then it's possibly going to have
4428  * column-level ACLs associated with it.
4429  */
4430  if (pg_class_tuple->relkind != RELKIND_SEQUENCE)
4431  {
4432  AttrNumber curr_att;
4433  AttrNumber nattrs = pg_class_tuple->relnatts;
4434 
4435  for (curr_att = 1; curr_att <= nattrs; curr_att++)
4436  {
4437  HeapTuple attTuple;
4438  Datum attaclDatum;
4439 
4440  attTuple = SearchSysCache2(ATTNUM,
4441  ObjectIdGetDatum(objoid),
4442  Int16GetDatum(curr_att));
4443 
4444  if (!HeapTupleIsValid(attTuple))
4445  continue;
4446 
4447  /* ignore dropped columns */
4448  if (((Form_pg_attribute) GETSTRUCT(attTuple))->attisdropped)
4449  {
4450  ReleaseSysCache(attTuple);
4451  continue;
4452  }
4453 
4454  attaclDatum = SysCacheGetAttr(ATTNUM, attTuple,
4455  Anum_pg_attribute_attacl,
4456  &isNull);
4457 
4458  /* no need to do anything for a NULL ACL */
4459  if (isNull)
4460  {
4461  ReleaseSysCache(attTuple);
4462  continue;
4463  }
4464 
4465  recordExtensionInitPrivWorker(objoid, classoid, curr_att,
4466  DatumGetAclP(attaclDatum));
4467 
4468  ReleaseSysCache(attTuple);
4469  }
4470  }
4471 
4472  aclDatum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relacl,
4473  &isNull);
4474 
4475  /* Add the record, if any, for the top-level object */
4476  if (!isNull)
4477  recordExtensionInitPrivWorker(objoid, classoid, 0,
4478  DatumGetAclP(aclDatum));
4479 
4480  ReleaseSysCache(tuple);
4481  }
4482  else if (classoid == LargeObjectRelationId)
4483  {
4484  /* For large objects, we must consult pg_largeobject_metadata */
4485  Datum aclDatum;
4486  bool isNull;
4487  HeapTuple tuple;
4488  ScanKeyData entry[1];
4489  SysScanDesc scan;
4490  Relation relation;
4491 
4492  /*
4493  * Note: this is dead code, given that we don't allow large objects to
4494  * be made extension members. But it seems worth carrying in case
4495  * some future caller of this function has need for it.
4496  */
4497  relation = table_open(LargeObjectMetadataRelationId, RowExclusiveLock);
4498 
4499  /* There's no syscache for pg_largeobject_metadata */
4500  ScanKeyInit(&entry[0],
4501  Anum_pg_largeobject_metadata_oid,
4502  BTEqualStrategyNumber, F_OIDEQ,
4503  ObjectIdGetDatum(objoid));
4504 
4505  scan = systable_beginscan(relation,
4506  LargeObjectMetadataOidIndexId, true,
4507  NULL, 1, entry);
4508 
4509  tuple = systable_getnext(scan);
4510  if (!HeapTupleIsValid(tuple))
4511  elog(ERROR, "could not find tuple for large object %u", objoid);
4512 
4513  aclDatum = heap_getattr(tuple,
4514  Anum_pg_largeobject_metadata_lomacl,
4515  RelationGetDescr(relation), &isNull);
4516 
4517  /* Add the record, if any, for the top-level object */
4518  if (!isNull)
4519  recordExtensionInitPrivWorker(objoid, classoid, 0,
4520  DatumGetAclP(aclDatum));
4521 
4522  systable_endscan(scan);
4523  }
4524  /* This will error on unsupported classoid. */
4525  else if (get_object_attnum_acl(classoid) != InvalidAttrNumber)
4526  {
4527  Datum aclDatum;
4528  bool isNull;
4529  HeapTuple tuple;
4530 
4531  tuple = SearchSysCache1(get_object_catcache_oid(classoid),
4532  ObjectIdGetDatum(objoid));
4533  if (!HeapTupleIsValid(tuple))
4534  elog(ERROR, "cache lookup failed for %s %u",
4535  get_object_class_descr(classoid), objoid);
4536 
4537  aclDatum = SysCacheGetAttr(get_object_catcache_oid(classoid), tuple,
4538  get_object_attnum_acl(classoid),
4539  &isNull);
4540 
4541  /* Add the record, if any, for the top-level object */
4542  if (!isNull)
4543  recordExtensionInitPrivWorker(objoid, classoid, 0,
4544  DatumGetAclP(aclDatum));
4545 
4546  ReleaseSysCache(tuple);
4547  }
4548 }
static void recordExtensionInitPrivWorker(Oid objoid, Oid classoid, int objsubid, Acl *new_acl)
Definition: aclchk.c:4667
#define InvalidAttrNumber
Definition: attnum.h:23
#define RowExclusiveLock
Definition: lockdefs.h:38
AttrNumber get_object_attnum_acl(Oid class_id)

References BTEqualStrategyNumber, DatumGetAclP, elog, ERROR, get_object_attnum_acl(), get_object_catcache_oid(), get_object_class_descr(), GETSTRUCT, heap_getattr(), HeapTupleIsValid, Int16GetDatum(), InvalidAttrNumber, ObjectIdGetDatum(), recordExtensionInitPrivWorker(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, ScanKeyInit(), SearchSysCache1(), SearchSysCache2(), SysCacheGetAttr(), systable_beginscan(), systable_endscan(), systable_getnext(), and table_open().

Referenced by ExecAlterExtensionContentsRecurse().

◆ removeExtObjInitPriv()

void removeExtObjInitPriv ( Oid  objoid,
Oid  classoid 
)

Definition at line 4555 of file aclchk.c.

4556 {
4557  /*
4558  * If this is a relation then we need to see if there are any sub-objects
4559  * (eg: columns) for it and, if so, be sure to call
4560  * recordExtensionInitPrivWorker() for each one.
4561  */
4562  if (classoid == RelationRelationId)
4563  {
4564  Form_pg_class pg_class_tuple;
4565  HeapTuple tuple;
4566 
4567  tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(objoid));
4568  if (!HeapTupleIsValid(tuple))
4569  elog(ERROR, "cache lookup failed for relation %u", objoid);
4570  pg_class_tuple = (Form_pg_class) GETSTRUCT(tuple);
4571 
4572  /*
4573  * Indexes don't have permissions, neither do the pg_class rows for
4574  * composite types. (These cases are unreachable given the
4575  * restrictions in ALTER EXTENSION DROP, but let's check anyway.)
4576  */
4577  if (pg_class_tuple->relkind == RELKIND_INDEX ||
4578  pg_class_tuple->relkind == RELKIND_PARTITIONED_INDEX ||
4579  pg_class_tuple->relkind == RELKIND_COMPOSITE_TYPE)
4580  {
4581  ReleaseSysCache(tuple);
4582  return;
4583  }
4584 
4585  /*
4586  * If this isn't a sequence then it's possibly going to have
4587  * column-level ACLs associated with it.
4588  */
4589  if (pg_class_tuple->relkind != RELKIND_SEQUENCE)
4590  {
4591  AttrNumber curr_att;
4592  AttrNumber nattrs = pg_class_tuple->relnatts;
4593 
4594  for (curr_att = 1; curr_att <= nattrs; curr_att++)
4595  {
4596  HeapTuple attTuple;
4597 
4598  attTuple = SearchSysCache2(ATTNUM,
4599  ObjectIdGetDatum(objoid),
4600  Int16GetDatum(curr_att));
4601 
4602  if (!HeapTupleIsValid(attTuple))
4603  continue;
4604 
4605  /* when removing, remove all entries, even dropped columns */
4606 
4607  recordExtensionInitPrivWorker(objoid, classoid, curr_att, NULL);
4608 
4609  ReleaseSysCache(attTuple);
4610  }
4611  }
4612 
4613  ReleaseSysCache(tuple);
4614  }
4615 
4616  /* Remove the record, if any, for the top-level object */
4617  recordExtensionInitPrivWorker(objoid, classoid, 0, NULL);
4618 }

References elog, ERROR, GETSTRUCT, HeapTupleIsValid, Int16GetDatum(), ObjectIdGetDatum(), recordExtensionInitPrivWorker(), ReleaseSysCache(), SearchSysCache1(), and SearchSysCache2().

Referenced by ExecAlterExtensionContentsRecurse().

◆ RemoveRoleFromObjectACL()

void RemoveRoleFromObjectACL ( Oid  roleid,
Oid  classid,
Oid  objid 
)

Definition at line 1453 of file aclchk.c.

1454 {
1455  if (classid == DefaultAclRelationId)
1456  {
1457  InternalDefaultACL iacls;
1458  Form_pg_default_acl pg_default_acl_tuple;
1459  Relation rel;
1460  ScanKeyData skey[1];
1461  SysScanDesc scan;
1462  HeapTuple tuple;
1463 
1464  /* first fetch info needed by SetDefaultACL */
1465  rel = table_open(DefaultAclRelationId, AccessShareLock);
1466 
1467  ScanKeyInit(&skey[0],
1468  Anum_pg_default_acl_oid,
1469  BTEqualStrategyNumber, F_OIDEQ,
1470  ObjectIdGetDatum(objid));
1471 
1472  scan = systable_beginscan(rel, DefaultAclOidIndexId, true,
1473  NULL, 1, skey);
1474 
1475  tuple = systable_getnext(scan);
1476 
1477  if (!HeapTupleIsValid(tuple))
1478  elog(ERROR, "could not find tuple for default ACL %u", objid);
1479 
1480  pg_default_acl_tuple = (Form_pg_default_acl) GETSTRUCT(tuple);
1481 
1482  iacls.roleid = pg_default_acl_tuple->defaclrole;
1483  iacls.nspid = pg_default_acl_tuple->defaclnamespace;
1484 
1485  switch (pg_default_acl_tuple->defaclobjtype)
1486  {
1487  case DEFACLOBJ_RELATION:
1488  iacls.objtype = OBJECT_TABLE;
1489  break;
1490  case DEFACLOBJ_SEQUENCE:
1491  iacls.objtype = OBJECT_SEQUENCE;
1492  break;
1493  case DEFACLOBJ_FUNCTION:
1494  iacls.objtype = OBJECT_FUNCTION;
1495  break;
1496  case DEFACLOBJ_TYPE:
1497  iacls.objtype = OBJECT_TYPE;
1498  break;
1499  case DEFACLOBJ_NAMESPACE:
1500  iacls.objtype = OBJECT_SCHEMA;
1501  break;
1502  default:
1503  /* Shouldn't get here */
1504  elog(ERROR, "unexpected default ACL type: %d",
1505  (int) pg_default_acl_tuple->defaclobjtype);
1506  break;
1507  }
1508 
1509  systable_endscan(scan);
1511 
1512  iacls.is_grant = false;
1513  iacls.all_privs = true;
1514  iacls.privileges = ACL_NO_RIGHTS;
1515  iacls.grantees = list_make1_oid(roleid);
1516  iacls.grant_option = false;
1517  iacls.behavior = DROP_CASCADE;
1518 
1519  /* Do it */
1520  SetDefaultACL(&iacls);
1521  }
1522  else
1523  {
1524  InternalGrant istmt;
1525 
1526  switch (classid)
1527  {
1528  case RelationRelationId:
1529  /* it's OK to use TABLE for a sequence */
1530  istmt.objtype = OBJECT_TABLE;
1531  break;
1532  case DatabaseRelationId:
1533  istmt.objtype = OBJECT_DATABASE;
1534  break;
1535  case TypeRelationId:
1536  istmt.objtype = OBJECT_TYPE;
1537  break;
1538  case ProcedureRelationId:
1539  istmt.objtype = OBJECT_ROUTINE;
1540  break;
1541  case LanguageRelationId:
1542  istmt.objtype = OBJECT_LANGUAGE;
1543  break;
1544  case LargeObjectRelationId:
1545  istmt.objtype = OBJECT_LARGEOBJECT;
1546  break;
1547  case NamespaceRelationId:
1548  istmt.objtype = OBJECT_SCHEMA;
1549  break;
1550  case TableSpaceRelationId:
1551  istmt.objtype = OBJECT_TABLESPACE;
1552  break;
1553  case ForeignServerRelationId:
1555  break;
1556  case ForeignDataWrapperRelationId:
1557  istmt.objtype = OBJECT_FDW;
1558  break;
1559  case ParameterAclRelationId:
1560  istmt.objtype = OBJECT_PARAMETER_ACL;
1561  break;
1562  default:
1563  elog(ERROR, "unexpected object class %u", classid);
1564  break;
1565  }
1566  istmt.is_grant = false;
1567  istmt.objects = list_make1_oid(objid);
1568  istmt.all_privs = true;
1569  istmt.privileges = ACL_NO_RIGHTS;
1570  istmt.col_privs = NIL;
1571  istmt.grantees = list_make1_oid(roleid);
1572  istmt.grant_option = false;
1573  istmt.behavior = DROP_CASCADE;
1574 
1575  ExecGrantStmt_oids(&istmt);
1576  }
1577 }
static void SetDefaultACL(InternalDefaultACL *iacls)
Definition: aclchk.c:1202
@ DROP_CASCADE
Definition: parsenodes.h:2183
FormData_pg_default_acl * Form_pg_default_acl
#define list_make1_oid(x1)
Definition: pg_list.h:242

References AccessShareLock, ACL_NO_RIGHTS, InternalDefaultACL::all_privs, InternalGrant::all_privs, InternalDefaultACL::behavior, InternalGrant::behavior, BTEqualStrategyNumber, InternalGrant::col_privs, DROP_CASCADE, elog, ERROR, ExecGrantStmt_oids(), GETSTRUCT, InternalDefaultACL::grant_option, InternalGrant::grant_option, InternalDefaultACL::grantees, InternalGrant::grantees, HeapTupleIsValid, InternalDefaultACL::is_grant, InternalGrant::is_grant, list_make1_oid, NIL, InternalDefaultACL::nspid, OBJECT_DATABASE, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FUNCTION, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_PARAMETER_ACL, OBJECT_ROUTINE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TYPE, ObjectIdGetDatum(), InternalGrant::objects, InternalDefaultACL::objtype, InternalGrant::objtype, InternalDefaultACL::privileges, InternalGrant::privileges, InternalDefaultACL::roleid, ScanKeyInit(), SetDefaultACL(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by shdepDropOwned().

◆ select_best_admin()

Oid select_best_admin ( Oid  member,
Oid  role 
)

Definition at line 5221 of file acl.c.

5222 {
5223  Oid admin_role;
5224 
5225  /* By policy, a role cannot have WITH ADMIN OPTION on itself. */
5226  if (member == role)
5227  return InvalidOid;
5228 
5229  (void) roles_is_member_of(member, ROLERECURSE_PRIVS, role, &admin_role);
5230  return admin_role;
5231 }

References InvalidOid, ROLERECURSE_PRIVS, and roles_is_member_of().

Referenced by check_role_grantor().

◆ select_best_grantor()

void select_best_grantor ( Oid  roleId,
AclMode  privileges,
const Acl acl,
Oid  ownerId,
Oid grantorId,
AclMode grantOptions 
)

Definition at line 5276 of file acl.c.

5279 {
5280  AclMode needed_goptions = ACL_GRANT_OPTION_FOR(privileges);
5281  List *roles_list;
5282  int nrights;
5283  ListCell *l;
5284 
5285  /*
5286  * The object owner is always treated as having all grant options, so if
5287  * roleId is the owner it's easy. Also, if roleId is a superuser it's
5288  * easy: superusers are implicitly members of every role, so they act as
5289  * the object owner.
5290  */
5291  if (roleId == ownerId || superuser_arg(roleId))
5292  {
5293  *grantorId = ownerId;
5294  *grantOptions = needed_goptions;
5295  return;
5296  }
5297 
5298  /*
5299  * Otherwise we have to do a careful search to see if roleId has the
5300  * privileges of any suitable role. Note: we can hang onto the result of
5301  * roles_is_member_of() throughout this loop, because aclmask_direct()
5302  * doesn't query any role memberships.
5303  */
5304  roles_list = roles_is_member_of(roleId, ROLERECURSE_PRIVS,
5305  InvalidOid, NULL);
5306 
5307  /* initialize candidate result as default */
5308  *grantorId = roleId;
5309  *grantOptions = ACL_NO_RIGHTS;
5310  nrights = 0;
5311 
5312  foreach(l, roles_list)
5313  {
5314  Oid otherrole = lfirst_oid(l);
5315  AclMode otherprivs;
5316 
5317  otherprivs = aclmask_direct(acl, otherrole, ownerId,
5318  needed_goptions, ACLMASK_ALL);
5319  if (otherprivs == needed_goptions)
5320  {
5321  /* Found a suitable grantor */
5322  *grantorId = otherrole;
5323  *grantOptions = otherprivs;
5324  return;
5325  }
5326 
5327  /*
5328  * If it has just some of the needed privileges, remember best
5329  * candidate.
5330  */
5331  if (otherprivs != ACL_NO_RIGHTS)
5332  {
5333  int nnewrights = count_one_bits(otherprivs);
5334 
5335  if (nnewrights > nrights)
5336  {
5337  *grantorId = otherrole;
5338  *grantOptions = otherprivs;
5339  nrights = nnewrights;
5340  }
5341  }
5342  }
5343 }
static int count_one_bits(AclMode mask)
Definition: acl.c:5236
static AclMode aclmask_direct(const Acl *acl, Oid roleid, Oid ownerId, AclMode mask, AclMaskHow how)
Definition: acl.c:1446
#define ACL_GRANT_OPTION_FOR(privs)
Definition: acl.h:70
#define lfirst_oid(lc)
Definition: pg_list.h:174

References ACL_GRANT_OPTION_FOR, ACL_NO_RIGHTS, ACLMASK_ALL, aclmask_direct(), count_one_bits(), InvalidOid, lfirst_oid, ROLERECURSE_PRIVS, roles_is_member_of(), and superuser_arg().

Referenced by ExecGrant_Attribute(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), and ExecGrant_Relation().