| //***************************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| //***************************************************************************** |
| |
| #ifndef PRIVMGR_DESC_H |
| #define PRIVMGR_DESC_H |
| |
| #include <bitset> |
| #include <string> |
| #include "PrivMgrMDDefs.h" |
| #include "PrivMgrDefs.h" |
| #include "ComSmallDefs.h" |
| |
| class ComDiags; |
| |
| // ***************************************************************************** |
| // Contents of file |
| // ***************************************************************************** |
| class PrivMgrCoreDesc; |
| class PrivMgrDesc; |
| |
| |
| |
| // ***************************************************************************** |
| // * |
| // * The privilege manager component stores privileges as bitmaps. |
| // * Classes and methods exist to create (grant), drop (revoke), and |
| // * peruse (select) privilege information for objects and user/roles. |
| // * |
| // * The PrivMgrCoreDesc class is the basic building block for privilege |
| // * support. It encapsulates the list of privileges assigned to a |
| // * object and user/role (grantee) assigned by the grantor into a bitmap. |
| // * It also encapsulates which privileges are grantable (WGO) by the grantor. |
| // * member: priv_ is the list of privileges |
| // * member: wgo_ is the corresponding grantable attribute |
| // * |
| // * The PrivMgrDesc class contains a list of priv_/wgo_ combinations. |
| // * Privileges can be granted at the schema, object, and column level. |
| // * The PrivMgrDesc class returns information about privileges on objects |
| // * for grantees across all level of privileges. |
| // * |
| // **************************************************************************** |
| |
| |
| // ***************************************************************************** |
| // * |
| // * Class: PrivMgrCoreDesc |
| // * Description: This class defines the basic representation of privilege and |
| // * WGO. It can be used to carry the privilege settings for |
| // * some (unspecified) user on some (unspecified) object, either |
| // * as granted by some grantor, or summarized over all grantors. |
| // * |
| // * When used to represent privileges held, the valid combinations are: |
| // * |
| // * priv_ wgo_ |
| // * ----- ---- |
| // * F F priv not held |
| // * T F priv held, not grantable |
| // * T T priv held, grantable. |
| // * |
| // * So the wgo_ value can be regarded as an option (which it is) on the |
| // * priv_ value, having meaning only if priv_ = T. |
| // * |
| // * When used to represent privileges to be granted, the valid combinations |
| // * are the same as the above, with the following interpretations: |
| // * priv_ wgo_ |
| // * ----- ---- |
| // * F F no change to privilege |
| // * T F priv to be granted, but not wgo |
| // * T T priv to be granted, wgo. |
| // * |
| // * When used to represent privileges which have been successfully granted, |
| // * all four possible combinations are valid: |
| // * priv_ wgo_ |
| // * ----- ---- |
| // * F F no change to privilege |
| // * F T only wgo was granted (priv was already held) |
| // * T F priv was granted, but not wgo |
| // * T T priv was granted wgo. |
| // * |
| // * When used to represent privileges to be revoked, the valid combinations |
| // * are: |
| // * priv_ wgo_ |
| // * ----- ---- |
| // * F F nothing to be revoked |
| // * F T revoke grant option only |
| // * T T revoke priv and grant option. |
| // * |
| // * Here the priv_ can be regarded as an option on the wgo_ value. We always |
| // * revoke the wgo (if we revoke anything at all), and optionally revoke the |
| // * entire privilege. |
| // * "Revoke SELECT on.." is represented as T T. |
| // * "Revoke grant option for SELECT on.." is represented as F T. |
| // * |
| // * When used to represent privileges which have been successfully revoked, |
| // * all four possible combinations are valid: |
| // * priv_ wgo_ |
| // * ----- ---- |
| // * F F nothing was revoked |
| // * F T only the grant option was revoked (priv remains) |
| // * T F only priv was revoked (wgo was not currently held) |
| // * T T priv and grant option were revoked. |
| // * |
| // ***************************************************************************** |
| |
| class PrivMgrCoreDesc |
| { |
| public: |
| |
| // PrivResult indicates the result of a Grant/Revoke operation. |
| // NONE means none of the specified privs were actually |
| // granted/revoked. |
| // SOME means some but not all .. |
| // ALL means all .. |
| // NEUTRAL means no privs were specified could be changed. |
| enum PrivResult { NONE, SOME, ALL, NEUTRAL }; |
| |
| // PrivChanges indicates the result of a replacement operation. |
| // NO_CHANGE means the privilege settings are unchanged. |
| // DECREASE means some privileges were lost. |
| // INCREASE means some privileges were added. |
| // AMBIGUOUS means some privileges were lost, others added. |
| enum PrivChanges { NO_CHANGE, DECREASE, INCREASE, AMBIGUOUS }; |
| |
| PrivMgrCoreDesc() |
| { |
| priv_.reset(); |
| wgo_.reset(); |
| columnOrdinal_ = -1; |
| } |
| |
| PrivMgrCoreDesc(PrivMgrBitmap privBits, |
| PrivMgrBitmap wgoBits) |
| : priv_(privBits) |
| , wgo_(wgoBits) |
| , columnOrdinal_ (-1) |
| {} |
| |
| PrivMgrCoreDesc(PrivMgrBitmap privBits, |
| PrivMgrBitmap wgoBits, |
| int32_t columnOrdinal) |
| : priv_(privBits) |
| , wgo_(wgoBits) |
| , columnOrdinal_ (columnOrdinal) |
| {} |
| |
| |
| PrivMgrCoreDesc(const PrivMgrCoreDesc&other) // copy constructor |
| { |
| priv_ = other.priv_; |
| wgo_ = other.wgo_; |
| columnOrdinal_ = other.columnOrdinal_; |
| } |
| |
| virtual ~PrivMgrCoreDesc() // destructor |
| {} |
| |
| // assignment operator |
| PrivMgrCoreDesc& operator=(const PrivMgrCoreDesc& other) |
| { |
| // Check for pathological case of X == X. |
| if ( this == &other ) |
| return *this; |
| |
| priv_ = other.priv_; |
| wgo_ = other.wgo_; |
| columnOrdinal_ = other.columnOrdinal_; |
| |
| return *this; |
| } |
| |
| |
| // comparison operator |
| bool operator==(const PrivMgrCoreDesc& other) const; |
| |
| // isNull - returns True iff no privs or wgos are set |
| bool isNull() const {return ( ( priv_.none() ) && ( wgo_.none() ) );} |
| |
| |
| // isNullWgo - returns True iff no wgos are set |
| bool isNullWgo() const { return ( wgo_.none() ); } |
| |
| // union -- modify the privilege settings by ORing values |
| // of another PrivMgrCoreDesc with this one. |
| void unionOfPrivs(const PrivMgrCoreDesc& other) |
| { |
| priv_ |= other.priv_; |
| wgo_ |= other.wgo_; |
| } |
| |
| // intersection -- modify the privilege settings by ANDing values |
| // of another PrivMgrCoreDesc with this one. |
| void intersectionOfPrivs(const PrivMgrCoreDesc& other) |
| { |
| priv_ &= other.priv_; |
| wgo_ &= other.wgo_; |
| } |
| |
| // complement -- replace the privilege settings with their complement. |
| void complementPrivs() |
| { |
| priv_.flip(); |
| wgo_.flip(); |
| } |
| |
| // AndNot -- sets "this" to "this" AND NOT "other" |
| void AndNot( const PrivMgrCoreDesc& other ); |
| |
| // grant -- modify the privilege settings of target PrivMgrCoreDesc |
| // by ORing values of this one. Change values of this |
| // to carry only the privileges actually granted. |
| // (Refer to the .cpp file for the algorithm.) |
| PrivResult grantPrivs(PrivMgrCoreDesc& other); |
| |
| // revoke -- modify the privilege settings of target PrivMgrCoreDesc |
| // by ANDing values of this one. Change values of this |
| // to carry only the privileges actually revoked. |
| // (Refer to the .cpp file for the algorithm.) |
| PrivResult revokePrivs(PrivMgrCoreDesc& other); |
| |
| // replace -- replace the privilege settings of this PrivMgrCoreDesc |
| // with the values of the specified one. Return value |
| // indicates whether privs were decreased/increased. |
| // When privs are lost, return those values in lostPrivs. |
| PrivChanges replacePrivs(const PrivMgrCoreDesc& other |
| , PrivMgrCoreDesc& lostPrivs); |
| |
| // Remove from this descriptor any privileges which |
| // are not held WGO in other. |
| // Return True if any privileges were removed; else False. |
| bool limitToGrantable( const PrivMgrCoreDesc& other ); |
| |
| // Remove from this descriptor any priv/wgo settings |
| // which also appear in other. |
| // Return True if any privileges were removed; else False. |
| bool suppressDuplicatedPrivs( const PrivMgrCoreDesc& other ); |
| |
| // Return True iff any priv/wgo flag set in this is not set in other. |
| // (Evaluate whether this && !other is null.) |
| bool anyNotSet( const PrivMgrCoreDesc& other ) const; |
| |
| // For any priv/wgo flag set in this is not set in other, |
| // unset the value in this. |
| // Return True if any change was made. |
| bool cascadeAnyNotSet( const PrivMgrCoreDesc& other ); |
| |
| // Returns true if the bit was set in the bitmap. It returns |
| // false is the bit was already set. If false is returned, |
| // then there are probably duplicate privileges specified in |
| // the privilege list |
| inline bool testAndSetBit(PrivType i, bool isWGOSpecified, bool isGOFSpecified); |
| |
| // ------------------------------------------------------------------- |
| // Accessors: |
| // ------------------------------------------------------------------- |
| PrivMgrBitmap getPrivBitmap (void) const { return priv_; } |
| bool getPriv(const PrivType which) const { return priv_.test(which); } |
| |
| PrivMgrBitmap getWgoBitmap (void) const { return wgo_; } |
| bool getWgo(const PrivType which) const { return wgo_.test(which); } |
| |
| int32_t getColumnOrdinal (void) const { return columnOrdinal_; } |
| |
| // ------------------------------------------------------------------- |
| // Mutators: |
| // ------------------------------------------------------------------- |
| void setPriv(const PrivType which, |
| const bool value); |
| void setWgo(const PrivType which, |
| const bool value); |
| void setAllPrivAndWgo(const bool val); |
| |
| void setAllObjectPrivileges( |
| const ComObjectType objectType, |
| const bool priv, |
| const bool wgo); |
| |
| inline void setAllLibraryGrantPrivileges( |
| const bool priv, |
| const bool wgo) |
| { |
| setPriv(UPDATE_PRIV, priv); |
| setWgo(UPDATE_PRIV, wgo); |
| setPriv(USAGE_PRIV, priv); |
| setWgo(USAGE_PRIV, wgo); |
| } |
| |
| inline void setAllTableGrantPrivileges( |
| const bool priv, |
| const bool wgo) |
| { |
| setPriv(SELECT_PRIV, priv); |
| setWgo(SELECT_PRIV, wgo); |
| setPriv(INSERT_PRIV, priv); |
| setWgo(INSERT_PRIV, wgo); |
| setPriv(DELETE_PRIV, priv); |
| setWgo(DELETE_PRIV, wgo); |
| setPriv(UPDATE_PRIV, priv); |
| setWgo(UPDATE_PRIV, wgo); |
| setPriv(REFERENCES_PRIV, priv); |
| setWgo(REFERENCES_PRIV, wgo); |
| } |
| |
| inline void setAllSequenceGrantPrivileges( |
| const bool priv, |
| const bool wgo) |
| { |
| setPriv(USAGE_PRIV, priv); |
| setWgo(USAGE_PRIV, wgo); |
| } |
| |
| inline void setAllUdrGrantPrivileges( |
| const bool priv, |
| const bool wgo) |
| { |
| setPriv(EXECUTE_PRIV, priv); |
| setWgo(EXECUTE_PRIV, wgo); |
| } |
| |
| inline void setColumnOrdinal( const int32_t columnOrdinal ) { columnOrdinal_ = columnOrdinal; } |
| inline void setPrivBitmap (PrivMgrBitmap priv) { priv_ = priv; } |
| inline void setWgoBitmap (PrivMgrBitmap wgo) { wgo_ = wgo; } |
| |
| |
| |
| private: |
| PrivMgrBitmap priv_; // Bit == True if the privilege is held. |
| |
| PrivMgrBitmap wgo_; // == True if the priv is held grantable. |
| |
| int32_t columnOrdinal_; |
| |
| // Private helper function to interpret changes to specified privs. |
| void interpretChanges( const bool before, // in |
| const bool after, // in |
| PrivResult& result ); // in/out |
| |
| }; // class PrivMgrCoreDesc |
| |
| inline bool PrivMgrCoreDesc::testAndSetBit(PrivType i, bool isWGOSpecified, bool isGOFSpecified) |
| { |
| if (isGOFSpecified) |
| { |
| if (wgo_.test(i)) |
| return false; |
| wgo_.set(i, true); |
| } |
| else |
| { |
| if (priv_.test(i)) |
| return false; |
| priv_.set(i, true); |
| wgo_.set(i, isWGOSpecified); |
| } |
| return true; |
| } |
| |
| /* ******************************************************************* |
| * Class PrivMgrDesc -- Representation of all privs on an object |
| * for a specified Grantee and an unspecified Grantor (or over all Grantors). |
| * ****************************************************************** */ |
| class PrivMgrDesc |
| { |
| |
| public: |
| PrivMgrDesc(const PrivMgrDesc&other) // copy constructor |
| : tableLevel_(other.tableLevel_), |
| columnLevel_(other.columnLevel_), |
| grantee_(other.grantee_), |
| hasPublicPriv_(other.hasPublicPriv_) |
| {} |
| |
| PrivMgrDesc(const int32_t grantee, |
| const int32_t nbrCols = 0 // preset constructor |
| ) |
| : tableLevel_(), |
| columnLevel_(NULL), |
| grantee_(grantee), |
| hasPublicPriv_(false) |
| {} |
| |
| PrivMgrDesc(const PrivMgrDesc &privs, // preset constructor |
| const int32_t grantee) |
| : tableLevel_(privs.tableLevel_), |
| columnLevel_(privs.columnLevel_,NULL), |
| grantee_(privs.grantee_), |
| hasPublicPriv_(privs.hasPublicPriv_) |
| {} |
| |
| PrivMgrDesc(void) |
| : tableLevel_(), |
| columnLevel_(NULL), |
| grantee_(0), |
| hasPublicPriv_(false) |
| {} |
| |
| virtual ~PrivMgrDesc() // destructor |
| {} |
| |
| // assignment operator |
| PrivMgrDesc& operator=(const PrivMgrDesc& other) |
| { |
| // Check for pathological case of X == X. |
| if ( this == &other ) |
| return *this; |
| |
| tableLevel_ = other.tableLevel_; |
| columnLevel_ = other.columnLevel_; |
| grantee_ = other.grantee_; |
| hasPublicPriv_ = other.hasPublicPriv_; |
| |
| return *this; |
| } |
| |
| |
| // comparison operator |
| bool operator==(const PrivMgrDesc& other) const |
| { |
| // Check for pathological case of X == X. |
| if ( this == &other ) |
| return TRUE; |
| |
| // Not checking all members, should be okay |
| return ( |
| ( columnLevel_ == other.columnLevel_ ) && |
| ( tableLevel_ == other.tableLevel_ ) && |
| ( grantee_ == other.grantee_)); |
| } |
| |
| |
| // Union -- OR current privilege settings in this PrivMgrDesc with other |
| void unionOfPrivs(const PrivMgrDesc& other) |
| { tableLevel_.unionOfPrivs( other.tableLevel_ ); } |
| void unionOfPrivs(const PrivMgrCoreDesc& other) |
| { tableLevel_.unionOfPrivs( other); } |
| |
| // Intersection -- AND current privilege settings in this PrivMgrDesc with other |
| void intersectionOfPrivs(const PrivMgrDesc& other) |
| { tableLevel_.intersectionOfPrivs( other.tableLevel_ ); } |
| void intersectionOfPrivs(const PrivMgrCoreDesc& other) |
| { tableLevel_.intersectionOfPrivs( other); } |
| |
| |
| // Complement -- take the complement of each priv setting in this. |
| void complement() { tableLevel_.complementPrivs(); } |
| |
| // AndNot -- sets "this" to "this" AND NOT "other" |
| void AndNot( const PrivMgrDesc& other ); |
| |
| // isNull - returns True iff no privs or wgos |
| bool isNull() const |
| { |
| if (tableLevel_.isNull() ) |
| return isColumnLevelNull(); |
| return false; |
| } |
| |
| bool isColumnLevelNull() const |
| { |
| for (int i = 0; i < columnLevel_.entries(); i++) |
| if (!columnLevel_[i].isNull()) |
| return false; |
| return true; |
| } |
| |
| // isNullWgo - returns True iff no wgos are set |
| bool isNullWgo() const; |
| |
| // Remove from this descriptor any privileges |
| // (both priv and WGO) which are not held WGO in other. |
| // Return True if any privileges were removed; else False. |
| bool limitToGrantable( const PrivMgrDesc& other ); |
| |
| // Remove from this descriptor any priv/wgo settings |
| // which also appear in other. |
| // Return True if any privileges were removed; else False. |
| bool suppressDuplicatedPrivs( const PrivMgrDesc& other ); |
| |
| // Accessors |
| |
| PrivMgrCoreDesc getTablePrivs() const { return tableLevel_; } |
| NAList<PrivMgrCoreDesc> getColumnPrivs() const { return columnLevel_; } |
| |
| // Get the PrivMgrCoreDesc based on the columnOrdinal (column number) |
| int getColumnPriv(int32_t columnOrdinal) const |
| { |
| for (int i = 0; i < columnLevel_.entries(); i++) |
| if (columnLevel_[i].getColumnOrdinal() == columnOrdinal) return i; |
| return -1; |
| } |
| |
| int32_t getGrantee() const { return grantee_; } |
| PrivMgrCoreDesc & fetchTablePrivs(); |
| bool getOneTablePriv(const PrivType which) const; |
| bool getOneTableWgo(const PrivType which) const; |
| |
| // Mutators |
| |
| void setGrantee(const int32_t&grantee) { grantee_ = grantee; } |
| void setTablePrivs(const PrivMgrCoreDesc &privs) { tableLevel_ = privs; } |
| void resetTablePrivs() { tableLevel_.setAllPrivAndWgo(0); } |
| void setColumnPrivs(const NAList<PrivMgrCoreDesc> &privs) { columnLevel_ = privs; } |
| |
| void setAllObjectPrivileges( |
| const ComObjectType objectType, |
| const bool priv, |
| const bool wgo) |
| { |
| PrivMgrCoreDesc objectCorePrivs; |
| objectCorePrivs.setAllObjectPrivileges(objectType, priv, wgo); |
| setTablePrivs(objectCorePrivs); |
| } |
| |
| void setAllTableGrantPrivileges(const bool priv, const bool wgo) |
| { |
| PrivMgrCoreDesc tableCorePrivs; |
| tableCorePrivs.setAllTableGrantPrivileges(priv, wgo); |
| setTablePrivs(tableCorePrivs); |
| } |
| |
| void setAllLibraryGrantPrivileges(const bool priv, const bool wgo) |
| { |
| PrivMgrCoreDesc tableCorePrivs; |
| tableCorePrivs.setAllLibraryGrantPrivileges(priv, wgo); |
| setTablePrivs(tableCorePrivs); |
| } |
| |
| void setAllUdrGrantPrivileges(const bool priv, const bool wgo) |
| { |
| PrivMgrCoreDesc tableCorePrivs; |
| tableCorePrivs.setAllUdrGrantPrivileges(priv, wgo); |
| setTablePrivs(tableCorePrivs); |
| } |
| |
| void setAllSequenceGrantPrivileges(const bool priv, const bool wgo) |
| { |
| PrivMgrCoreDesc corePrivs; |
| corePrivs.setAllSequenceGrantPrivileges(priv, wgo); |
| setTablePrivs(corePrivs); |
| } |
| |
| bool getHasPublicPriv() { return hasPublicPriv_; } |
| void setHasPublicPriv(bool hasPublicPriv) { hasPublicPriv_ = hasPublicPriv; } |
| |
| PrivMgrCoreDesc::PrivResult grantTablePrivs(PrivMgrCoreDesc& priv) |
| { return tableLevel_.grantPrivs(priv); } |
| |
| PrivMgrCoreDesc::PrivResult revokeTablePrivs(PrivMgrCoreDesc& priv) |
| { return tableLevel_.revokePrivs(priv); } |
| |
| |
| void pTrace() const; // Debug trace |
| |
| |
| // Data members |
| private: |
| PrivMgrCoreDesc tableLevel_; |
| NAList<PrivMgrCoreDesc> columnLevel_; |
| int32_t grantee_; |
| bool hasPublicPriv_; |
| }; |
| |
| |
| /* ******************************************************************* |
| * Class PrivMgrDescList -- A list of PrivMgrDesc pointers |
| * ****************************************************************** */ |
| |
| class PrivMgrDescList : public LIST(PrivMgrDesc *) |
| { |
| public: |
| |
| // constructor |
| PrivMgrDescList(CollHeap *heap) |
| : LIST(PrivMgrDesc *)(heap), |
| heap_(heap) |
| {} |
| |
| // virtual destructor |
| virtual ~PrivMgrDescList() |
| { |
| for (CollIndex i = 0; i < entries(); i++) |
| NADELETE(operator[](i), PrivMgrDesc, heap_); |
| clear(); |
| } |
| |
| CollHeap *getHeap() { return heap_; } |
| |
| private: |
| |
| CollHeap *heap_; |
| |
| }; // class PrivMgrDescList |
| |
| |
| |
| #endif // PRIVMGR_DESC_H |
| |
