| //***************************************************************************** |
| // @@@ 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 @@@ |
| //***************************************************************************** |
| |
| // ========================================================================== |
| // Contains non inline methods in the following classes |
| // ComSecurityKey |
| // Contains helper function: qiCheckForInvalidKeys |
| // ========================================================================== |
| |
| #include "ComSecurityKey.h" |
| #include <bitset> |
| #include <string> |
| #include <vector> |
| #include "exp_function.h" |
| #include "ComDistribution.h" |
| #include "ComUser.h" |
| #include "PrivMgrDefs.h" |
| |
| // **************************************************************************** |
| // function: qiSubjectMatchesRole |
| // |
| // This function compares the subjectKey with the list of roles the current |
| // user has been granted. If it matches one of the roles, return TRUE, |
| // otherwise it returns FALSE. |
| // **************************************************************************** |
| NABoolean qiSubjectMatchesRole(uint32_t subjectKey) |
| { |
| NAList <Int32> roleIDs(NULL); |
| ComUser::getCurrentUserRoles(roleIDs); |
| for (int i = 0; i < roleIDs.entries(); i++) |
| { |
| if (subjectKey = ComSecurityKey::generateHash(roleIDs[i])) |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| // **************************************************************************** |
| // function: qiCheckForInvalidObject |
| // |
| // This function compares the list of query invalidate keys that changed to |
| // the list of invalidation keys associated with the object. |
| // |
| // If the changed invalidation key matches one of the keys for the object, |
| // return TRUE. TRUE indicates that the object should be reloaded to pick up |
| // DDL or privilege changes. |
| // **************************************************************************** |
| NABoolean qiCheckForInvalidObject (const Int32 numInvalidationKeys, |
| const SQL_QIKEY* invalidationKeys, |
| const Int64 objectUID, |
| const ComSecurityKeySet & objectKeys) |
| { |
| NABoolean found = FALSE; |
| ComQIActionType invalidationKeyType = COM_QI_INVALID_ACTIONTYPE; |
| |
| // check each invalidation key against objects in NATableDB or NARoutineDB |
| // cache |
| for ( Int32 i = 0; i < numInvalidationKeys && !found; i++ ) |
| { |
| invalidationKeyType = ComQIActionTypeLiteralToEnum( invalidationKeys[i].operation ); |
| Int32 numObjectKeys = objectKeys.entries(); |
| |
| switch (invalidationKeyType) |
| { |
| // Indicates that the DDL of the object has changed. |
| case COM_QI_OBJECT_REDEF: |
| // Indicates that the histogram statistics of the object has changed. |
| case COM_QI_STATS_UPDATED: |
| { |
| if (invalidationKeys[i].ddlObjectUID == objectUID) |
| found = TRUE; |
| break; |
| } |
| |
| // Scan the passed-in object keys to find any that match the subject, |
| // object, and key type. That is, the subject has the privilege |
| // (invalidation key type) on the object or a column of the object. |
| case COM_QI_OBJECT_SELECT: |
| case COM_QI_OBJECT_INSERT: |
| case COM_QI_OBJECT_DELETE: |
| case COM_QI_OBJECT_UPDATE: |
| case COM_QI_OBJECT_USAGE: |
| case COM_QI_OBJECT_REFERENCES: |
| case COM_QI_OBJECT_EXECUTE: |
| for (Int32 j = 0; j < numObjectKeys && !found; j++ ) |
| { |
| ComSecurityKey keyValue = objectKeys[j]; |
| if ( ( invalidationKeys[i].revokeKey.object == |
| keyValue.getObjectHashValue() ) && |
| ( invalidationKeyType == |
| keyValue.getSecurityKeyType() ) ) |
| { |
| if ( invalidationKeys[i].revokeKey.subject == |
| keyValue.getSubjectHashValue() || |
| qiSubjectMatchesRole(invalidationKeys[i].revokeKey.subject) ) |
| found = TRUE; |
| } |
| } |
| break; |
| case COM_QI_USER_GRANT_SPECIAL_ROLE: |
| case COM_QI_USER_GRANT_ROLE: |
| { |
| for (Int32 j = 0; j < numObjectKeys && !found; j++ ) |
| { |
| ComSecurityKey keyValue = objectKeys[j]; |
| if ( ( invalidationKeys[i].revokeKey.subject == |
| keyValue.getSubjectHashValue() ) && |
| ( invalidationKeys[i].revokeKey.object == |
| keyValue.getObjectHashValue() ) && |
| ( invalidationKeyType == |
| keyValue.getSecurityKeyType() ) ) |
| found = TRUE; |
| } |
| break; |
| } |
| |
| default: |
| found = TRUE; |
| break; |
| } |
| } |
| return found; |
| } |
| |
| // **************************************************************************** |
| // Function that builds query invalidation keys for privileges. A separate |
| // invalidation key is added for each granted DML privilege. |
| // |
| // Types of keys available for privs: |
| // OBJECT_IS_SCHEMA - not supported until we support schema level privs |
| // OBJECT_IS_OBJECT - supported for granting privs to user |
| // OBJECT_IS_COLUMN - not supported at this time |
| // OBJECT_IS_SPECIAL_ROLE - key for PUBLIC authorization ID |
| // SUBJECT_IS_USER - support for granting roles to user |
| // SUBJECT_IS_ROLE - not supported until we grant roles to roles |
| // |
| // returns false is unable to build keys |
| // **************************************************************************** |
| bool buildSecurityKeys( const int32_t userID, |
| const int32_t granteeID, |
| const int64_t objectUID, |
| const PrivMgrCoreDesc &privs, |
| ComSecurityKeySet &secKeySet ) |
| { |
| if (privs.isNull()) |
| return true; |
| |
| NABoolean doDebug = (getenv("DBUSER_DEBUG") ? TRUE : FALSE); |
| std::string msg ("Method: buildSecurityKeys: "); |
| if (doDebug) |
| { |
| printf("[DBUSER:%d] %s\n", (int) getpid(), msg.c_str()); |
| fflush(stdout); |
| } |
| |
| // If public is the grantee, generate special security key |
| // A user cannot be revoked from public |
| if (ComUser::isPublicUserID(granteeID)) |
| { |
| ComSecurityKey key(granteeID, ComSecurityKey::OBJECT_IS_SPECIAL_ROLE); |
| if (doDebug) |
| { |
| NAString msg (key.print(granteeID, objectUID)); |
| printf("[DBUSER:%d] (public) %s\n", (int) getpid(), msg.data()); |
| fflush(stdout); |
| } |
| |
| if (key.isValid()) |
| secKeySet.insert(key); |
| else |
| return false; |
| } |
| |
| // If the grantee is a role, generate a special security key |
| // If the role is revoked from the user, this key takes affect |
| if (PrivMgr::isRoleID(granteeID)) |
| { |
| ComSecurityKey key (userID, granteeID, ComSecurityKey::SUBJECT_IS_USER); |
| if (doDebug) |
| { |
| NAString msg = key.print(userID, granteeID); |
| printf("[DBUSER:%d] (role) %s\n", |
| (int) getpid(), msg.data()); |
| fflush(stdout); |
| } |
| |
| if (key.isValid()) |
| secKeySet.insert(key); |
| else |
| return false; |
| } |
| |
| // Generate object invalidation keys |
| // Only need to generate keys for DML privileges |
| for ( size_t i = FIRST_DML_PRIV; i <= LAST_DML_PRIV; i++ ) |
| { |
| if ( privs.getPriv(PrivType(i))) |
| { |
| ComSecurityKey key (granteeID, objectUID, PrivType(i), |
| ComSecurityKey::OBJECT_IS_OBJECT); |
| if (doDebug) |
| { |
| NAString msg = key.print(granteeID, objectUID); |
| printf("[DBUSER:%d] (DML)%s\n", |
| (int) getpid(), msg.data()); |
| fflush(stdout); |
| } |
| |
| if (key.isValid()) |
| secKeySet.insert(key); |
| else |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| // **************************************************************************** |
| // Function that returns the types of invalidation to perform |
| // For DDL invalidation keys, always need to update caches |
| // For security invalidation keys |
| // update caches if key is for an object revoke from the current user or |
| // current users roles |
| // reset list of roles if key is a revoke role from the current user |
| // |
| // returns: |
| // resetRoleList -- need to reset the list of roles for the current user |
| // updateCaches -- need to update cache entries related for the keys |
| // **************************************************************************** |
| void qiInvalidationType (const Int32 numInvalidationKeys, |
| const SQL_QIKEY* invalidationKeys, |
| const Int32 userID, |
| bool &resetRoleList, |
| bool &updateCaches) |
| { |
| NABoolean doDebug = (getenv("DBUSER_DEBUG") ? TRUE : FALSE); |
| char buf[100]; |
| |
| resetRoleList = false; |
| updateCaches = false; |
| ComQIActionType invalidationKeyType = COM_QI_INVALID_ACTIONTYPE; |
| |
| // Have the ComSecurityKey constructor compute the hash value for the the User's ID. |
| // Note: The following code doesn't care about the object's hash value or the resulting |
| // ComSecurityKey's ActionType....we just need the hash value for the User's ID. |
| // Perhaps a new constructor would be good (also done in RelRoot::checkPrivileges) |
| uint32_t userHashValue = ComSecurityKey::generateHash(userID); |
| |
| if (doDebug) |
| { |
| sprintf(buf, ": num keys(%d)", numInvalidationKeys); |
| printf("[DBUSER:%d] Method: qiInvalidationType%s\n", |
| (int) getpid(), buf); |
| fflush(stdout); |
| sprintf(buf, "Not applicable"); |
| } |
| |
| for ( Int32 i = 0; i < numInvalidationKeys; i++ ) |
| { |
| invalidationKeyType = ComQIActionTypeLiteralToEnum( invalidationKeys[i].operation ); |
| switch (invalidationKeyType) |
| { |
| // Object changed, need to update caches |
| case COM_QI_OBJECT_REDEF: |
| case COM_QI_STATS_UPDATED: |
| if (doDebug) |
| sprintf(buf, "object/stats, operation: %c%c, objectUID: %ld", |
| invalidationKeys[i].operation[0], |
| invalidationKeys[i].operation[1], |
| invalidationKeys[i].ddlObjectUID); |
| |
| updateCaches = true; |
| break; |
| |
| // Privilege changed on an object, need to update caches if |
| // any QI keys are associated with the current user |
| case COM_QI_OBJECT_SELECT: |
| case COM_QI_OBJECT_INSERT: |
| case COM_QI_OBJECT_DELETE: |
| case COM_QI_OBJECT_UPDATE: |
| case COM_QI_OBJECT_USAGE: |
| case COM_QI_OBJECT_REFERENCES: |
| case COM_QI_OBJECT_EXECUTE: |
| // If the current user matches the revoke subject, update |
| if (invalidationKeys[i].revokeKey.subject == userHashValue) |
| { |
| if (doDebug) |
| sprintf(buf, "user: %d, operation: %c%c, subject: %u, object: %u", userID, |
| invalidationKeys[i].operation[0], invalidationKeys[i].operation[1], |
| invalidationKeys[i].revokeKey.subject, invalidationKeys[i].revokeKey.object); |
| |
| updateCaches = true; |
| } |
| |
| // If one of the users roles matches the revokes subject, update |
| else if (qiSubjectMatchesRole(invalidationKeys[i].revokeKey.subject)) |
| { |
| if (doDebug) |
| sprintf(buf, "role: %d, operation: %c%c, subject: %u, object: %u", userID, |
| invalidationKeys[i].operation[0], invalidationKeys[i].operation[1], |
| invalidationKeys[i].revokeKey.subject, invalidationKeys[i].revokeKey.object); |
| |
| updateCaches = true; |
| } |
| break; |
| |
| // For public user (SPECIAL_ROLE), the subject is a special hash |
| case COM_QI_USER_GRANT_SPECIAL_ROLE: |
| if (invalidationKeys[i].revokeKey.subject == ComSecurityKey::SPECIAL_SUBJECT_HASH) |
| { |
| if (doDebug) |
| sprintf(buf, "user: %d, operation: %c%c, subject: %u, object: %u", userID, |
| invalidationKeys[i].operation[0], invalidationKeys[i].operation[1], |
| invalidationKeys[i].revokeKey.subject, invalidationKeys[i].revokeKey.object); |
| updateCaches = true; |
| } |
| break; |
| |
| // A revoke role from a user was performed. Need to reset role list |
| // if QI key associated with the current user and remove any plans |
| // that include the role key |
| case COM_QI_USER_GRANT_ROLE: |
| if (invalidationKeys[i].revokeKey.subject == userHashValue) |
| { |
| if (doDebug) |
| sprintf(buf, "user: %d, operation: %c%c, subject: %u, object: %u", userID, |
| invalidationKeys[i].operation[0], invalidationKeys[i].operation[1], |
| invalidationKeys[i].revokeKey.subject, invalidationKeys[i].revokeKey.object); |
| |
| resetRoleList = true; |
| updateCaches = true; |
| } |
| break; |
| |
| // If a role was granted, refresh the active role llist |
| case COM_QI_GRANT_ROLE: |
| if (doDebug) |
| sprintf(buf, "operation: %c%c, subject: %u, object: %u", |
| invalidationKeys[i].operation[0], invalidationKeys[i].operation[1], |
| invalidationKeys[i].revokeKey.subject, invalidationKeys[i].revokeKey.object); |
| |
| resetRoleList = true; |
| break; |
| |
| // unknown key type, search and update cache (should not happen) |
| default: |
| if (doDebug) |
| sprintf(buf, "user: %d, operation: %c%c, subject: %u, object: %u", userID, |
| invalidationKeys[i].operation[0], invalidationKeys[i].operation[1], |
| invalidationKeys[i].revokeKey.subject, invalidationKeys[i].revokeKey.object); |
| resetRoleList = true; |
| updateCaches = true; |
| break; |
| } |
| if (doDebug) |
| { |
| printf("[DBUSER:%d] %s\n", |
| (int) getpid(), buf); |
| fflush(stdout); |
| } |
| } |
| } |
| |
| |
| // ***************************************************************************** |
| // ComSecurityKey methods |
| // ***************************************************************************** |
| // Constructor for privilege grant on a SQL object to an authID |
| ComSecurityKey::ComSecurityKey(const int32_t subjectUserID, |
| const int64_t objectUID, |
| const PrivType which, |
| const QIType typeOfObject) |
| : |
| subjectHash_(0), |
| objectHash_(0), |
| actionType_(COM_QI_INVALID_ACTIONTYPE) |
| { |
| // Set the type. |
| actionType_ = convertBitmapToQIActionType(which, typeOfObject); |
| |
| if (actionType_ != COM_QI_INVALID_ACTIONTYPE) |
| { |
| // This is a valid key. Set the subject and object values. |
| |
| // Authorization ID of the grantee |
| // Hash value of the authorization ID of the subject |
| subjectHash_ = generateHash(subjectUserID); |
| // Hash value of the UID of the object |
| objectHash_ = generateHash(objectUID); |
| } |
| } |
| |
| ComSecurityKey::ComSecurityKey( |
| const int32_t subjectUserID, |
| const int64_t objectUserID, |
| const QIType typeOfSubject) |
| : |
| subjectHash_(0), |
| objectHash_(0), |
| actionType_(COM_QI_INVALID_ACTIONTYPE) |
| { |
| if (typeOfSubject == SUBJECT_IS_USER) |
| actionType_ = COM_QI_USER_GRANT_ROLE; // revoke role <object> from <user subject> |
| else if (typeOfSubject == SUBJECT_IS_GRANT_ROLE) |
| actionType_ = COM_QI_GRANT_ROLE; |
| else |
| actionType_ = COM_QI_ROLE_GRANT_ROLE; |
| |
| if (actionType_ != COM_QI_INVALID_ACTIONTYPE) |
| { |
| // This is a valid key. Set the subject and object values. |
| |
| // Authorization ID of the grantee |
| // Hash value of the authorization ID of the subject |
| subjectHash_ = generateHash(subjectUserID); |
| |
| // Hash value of the authorization ID of the object |
| objectHash_ = generateHash(objectUserID); |
| } |
| } |
| |
| // Constructor for a special role grant to an authID. |
| ComSecurityKey::ComSecurityKey( |
| const int32_t subjectUserID, |
| const QIType typeOfObject ) |
| : |
| subjectHash_(0), |
| objectHash_(0), |
| actionType_(COM_QI_INVALID_ACTIONTYPE) |
| { |
| // Set the values |
| if (typeOfObject == OBJECT_IS_SPECIAL_ROLE) |
| { |
| actionType_ = COM_QI_USER_GRANT_SPECIAL_ROLE; |
| subjectHash_ = SPECIAL_SUBJECT_HASH; |
| objectHash_ = SPECIAL_OBJECT_HASH; |
| } |
| } |
| |
| ComSecurityKey::ComSecurityKey() : |
| subjectHash_(0), |
| objectHash_(0), |
| actionType_(COM_QI_INVALID_ACTIONTYPE) |
| {}; |
| |
| bool ComSecurityKey::operator == (const ComSecurityKey &other) const |
| { |
| if((subjectHash_ == other.subjectHash_)&& |
| (objectHash_ == other.objectHash_) && |
| (actionType_ == other.actionType_)) |
| return true; |
| |
| return false; |
| } |
| |
| ComQIActionType ComSecurityKey::convertBitmapToQIActionType ( |
| const PrivType which, |
| const QIType inputType) const |
| { |
| // Convert from a PrivType value into a security key action type |
| // Note that this does not cover grant or revoke role |
| // Only converts values that are applicable to query invalidation. Returns an |
| // invalid value for all other privileges. |
| |
| // Need to differentiate between schema, object, and column |
| ComQIActionType result = COM_QI_INVALID_ACTIONTYPE; |
| |
| switch(which) |
| { |
| case SELECT_PRIV: |
| if (inputType == OBJECT_IS_OBJECT) |
| result = COM_QI_OBJECT_SELECT; |
| //else |
| // result = COM_QI_COLUMN_SELECT; |
| break; |
| case INSERT_PRIV: |
| if (inputType == OBJECT_IS_OBJECT) |
| result = COM_QI_OBJECT_INSERT; |
| //else |
| // result = COM_QI_COLUMN_INSERT; |
| break; |
| case DELETE_PRIV: |
| if (inputType == OBJECT_IS_OBJECT) |
| result = COM_QI_OBJECT_DELETE; |
| break; |
| case UPDATE_PRIV: |
| if (inputType == OBJECT_IS_OBJECT) |
| result = COM_QI_OBJECT_UPDATE; |
| //else |
| // result = COM_QI_COLUMN_UPDATE; |
| break; |
| case USAGE_PRIV: |
| if (inputType == OBJECT_IS_OBJECT) |
| result = COM_QI_OBJECT_USAGE; |
| break; |
| case REFERENCES_PRIV: |
| if (inputType == OBJECT_IS_OBJECT) |
| result = COM_QI_OBJECT_REFERENCES; |
| break; |
| case EXECUTE_PRIV: |
| if (inputType == OBJECT_IS_OBJECT) |
| result = COM_QI_OBJECT_EXECUTE; |
| else if (inputType == OBJECT_IS_SCHEMA) |
| result = COM_QI_SCHEMA_EXECUTE; |
| break; |
| default: |
| result = COM_QI_INVALID_ACTIONTYPE; |
| break; |
| }; |
| |
| return (result); |
| } |
| |
| // Basic method to generate hash values |
| uint32_t ComSecurityKey::generateHash(int64_t hashInput) |
| { |
| uint32_t hashResult = ExHDPHash::hash8((char*)&hashInput, ExHDPHash::NO_FLAGS); |
| return hashResult; |
| } |
| |
| // Generate hash value based on authorization ID |
| uint32_t ComSecurityKey::generateHash(int32_t hashID) |
| { |
| int64_t hVal = (int64_t) hashID; |
| uint32_t hashResult = generateHash(hVal); |
| return hashResult; |
| } |
| |
| void ComSecurityKey::getSecurityKeyTypeAsLit (std::string &actionString) const |
| { |
| switch(actionType_) |
| { |
| case COM_QI_GRANT_ROLE: |
| actionString = COM_QI_GRANT_ROLE_LIT; |
| break; |
| case COM_QI_USER_GRANT_ROLE: |
| actionString = COM_QI_USER_GRANT_ROLE_LIT; |
| break; |
| case COM_QI_ROLE_GRANT_ROLE: |
| actionString = COM_QI_ROLE_GRANT_ROLE_LIT; |
| break; |
| case COM_QI_OBJECT_SELECT: |
| actionString = COM_QI_OBJECT_SELECT_LIT; |
| break; |
| case COM_QI_OBJECT_INSERT: |
| actionString = COM_QI_OBJECT_INSERT_LIT; |
| break; |
| case COM_QI_OBJECT_DELETE: |
| actionString = COM_QI_OBJECT_DELETE_LIT; |
| break; |
| case COM_QI_OBJECT_UPDATE: |
| actionString = COM_QI_OBJECT_UPDATE_LIT; |
| break; |
| case COM_QI_OBJECT_USAGE: |
| actionString = COM_QI_OBJECT_USAGE_LIT; |
| break; |
| case COM_QI_OBJECT_REFERENCES: |
| actionString = COM_QI_OBJECT_REFERENCES_LIT; |
| break; |
| case COM_QI_SCHEMA_SELECT: |
| actionString = COM_QI_SCHEMA_SELECT_LIT; |
| break; |
| case COM_QI_SCHEMA_INSERT: |
| actionString = COM_QI_SCHEMA_INSERT_LIT; |
| break; |
| case COM_QI_SCHEMA_DELETE: |
| actionString = COM_QI_SCHEMA_DELETE_LIT; |
| break; |
| case COM_QI_SCHEMA_UPDATE: |
| actionString = COM_QI_SCHEMA_UPDATE_LIT; |
| break; |
| case COM_QI_OBJECT_EXECUTE: |
| actionString = COM_QI_OBJECT_EXECUTE_LIT; |
| break; |
| case COM_QI_SCHEMA_EXECUTE: |
| actionString = COM_QI_SCHEMA_EXECUTE_LIT; |
| break; |
| case COM_QI_USER_GRANT_SPECIAL_ROLE: |
| actionString = COM_QI_USER_GRANT_SPECIAL_ROLE_LIT; |
| break; |
| default: |
| actionString = COM_QI_INVALID_ACTIONTYPE_LIT; |
| } |
| } |
| |
| NAString ComSecurityKey::print(Int32 subjectID, Int64 objectID) |
| { |
| std::string typeString; |
| switch(actionType_) |
| { |
| case COM_QI_GRANT_ROLE: |
| typeString = "GRANT_ROLE"; |
| break; |
| case COM_QI_USER_GRANT_ROLE: |
| typeString = "USER_GRANT_ROLE"; |
| break; |
| case COM_QI_ROLE_GRANT_ROLE: |
| typeString = "ROLE_GRANT_ROLE"; |
| break; |
| case COM_QI_SCHEMA_SELECT: |
| typeString = "SCHEMA_SELECT"; |
| break; |
| case COM_QI_SCHEMA_INSERT: |
| typeString = "SCHEMA_INSERT"; |
| break; |
| case COM_QI_SCHEMA_DELETE: |
| typeString = "SCHEMA_DELETE"; |
| break; |
| case COM_QI_SCHEMA_UPDATE: |
| typeString = "SCHEMA_UPDATE"; |
| break; |
| case COM_QI_OBJECT_SELECT: |
| typeString = "OBJECT_SELECT"; |
| break; |
| case COM_QI_OBJECT_INSERT: |
| typeString = "OBJECT_INSERT"; |
| break; |
| case COM_QI_OBJECT_DELETE: |
| typeString = "OBJECT_DELETE"; |
| break; |
| case COM_QI_OBJECT_UPDATE: |
| typeString = "OBJECT_UPDATE"; |
| break; |
| case COM_QI_OBJECT_USAGE: |
| typeString = "OBJECT_USAGE"; |
| break; |
| case COM_QI_OBJECT_REFERENCES: |
| typeString = "OBJECT_REFERENCES"; |
| break; |
| default: |
| typeString = "INVALID_ACTIONTYPE"; |
| break; |
| }; |
| char buf[200]; |
| sprintf (buf, " - subjectHash: %u (%d), objectHash: %u (%ld), type: %s", |
| subjectHash_, subjectID, |
| objectHash_, objectID, |
| typeString.data()); |
| NAString keyDetails = buf; |
| return keyDetails; |
| } |
| |
| |
