From 2c25de36cc61e09e4e4a89ecd7596529c0281ef7 Mon Sep 17 00:00:00 2001 From: youliang_1314 Date: Fri, 1 Jul 2022 10:28:19 +0800 Subject: [PATCH 1/7] add trace Signed-off-by: youliang_1314 Change-Id: I8d1e2df39157f9453f5db03fe3fa343f91f8f35b --- services/BUILD.gn | 2 + services/common_defines/interfaces/user_idm.h | 2 +- services/common_defines/types/iam_types.h | 10 ++ services/context/inc/base_context.h | 3 +- services/context/inc/context.h | 9 -- services/context/inc/context_callback.h | 78 ++++++++++++ services/context/inc/context_factory.h | 10 +- services/context/src/base_context.cpp | 8 -- .../context/src/context_callback_impl.cpp | 102 +++++++++++++++- services/context/src/context_callback_impl.h | 19 ++- services/context/src/context_factory.cpp | 19 ++- services/context/src/enroll_context.cpp | 5 +- services/context/src/identify_context.cpp | 9 +- services/context/src/simple_auth_context.cpp | 11 +- services/dfx/trace.cpp | 55 +++++++++ services/dfx/trace.h | 38 ++++++ services/ipc/inc/user_idm_service.h | 2 +- services/ipc/src/user_auth_service.cpp | 61 ++++++---- services/ipc/src/user_idm_service.cpp | 112 +++++++++++++----- services/ipc/src/user_idm_stub.cpp | 6 +- 20 files changed, 445 insertions(+), 116 deletions(-) create mode 100644 services/context/inc/context_callback.h create mode 100644 services/dfx/trace.cpp create mode 100644 services/dfx/trace.h diff --git a/services/BUILD.gn b/services/BUILD.gn index b576f7c4f..680ab8060 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -27,6 +27,7 @@ ohos_shared_library("userauthservice") { "core/src", "context/inc", "ipc/inc", + "dfx", "common_defines/types", "common_defines/interfaces", "//base/useriam/user_auth_framework/common/utils", @@ -74,6 +75,7 @@ ohos_shared_library("userauthservice") { "ipc/src/user_idm_callback_proxy.cpp", "ipc/src/user_idm_service.cpp", "ipc/src/user_idm_stub.cpp", + "dfx/trace.cpp", ] deps = [ diff --git a/services/common_defines/interfaces/user_idm.h b/services/common_defines/interfaces/user_idm.h index 63c687eaa..f2ba6f5b2 100644 --- a/services/common_defines/interfaces/user_idm.h +++ b/services/common_defines/interfaces/user_idm.h @@ -92,7 +92,7 @@ public: * param callback get results / acquire info callback. */ virtual void AddCredential(std::optional userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, const sptr &callback) = 0; + const std::vector &token, const sptr &callback, bool isUpdate) = 0; /* * update user credential information. * diff --git a/services/common_defines/types/iam_types.h b/services/common_defines/types/iam_types.h index 69d25c449..e2ebe00eb 100644 --- a/services/common_defines/types/iam_types.h +++ b/services/common_defines/types/iam_types.h @@ -62,6 +62,16 @@ enum ScheduleMode : uint32_t { IDENTIFY = 2, }; +enum OperationType : uint32_t { + ADD_CREDENTIAL = 0, + DELETE_CREDENTIAL = 1, + DELETE_USER = 2, + ENFORCE_DELETE_USER = 3, + UPDATE_CREDENTIAL = 4, + USER_AUTH = 5, + PIN_AUTH = 6, +}; + enum PropertyMode : uint32_t { PROPERTY_MODE_DEL = 0, PROPERTY_MODE_GET = 1, diff --git a/services/context/inc/base_context.h b/services/context/inc/base_context.h index 4119c2c29..0fc77fc00 100644 --- a/services/context/inc/base_context.h +++ b/services/context/inc/base_context.h @@ -24,6 +24,7 @@ #include "nocopyable.h" #include "context.h" +#include "context_callback.h" namespace OHOS { namespace UserIam { @@ -38,7 +39,6 @@ public: uint64_t GetContextId() const override; std::shared_ptr GetScheduleNode(uint64_t scheduleId) const override; - void SetContextStopCallback(ContextStopCallback callback) override; void OnScheduleStarted() override; void OnScheduleProcessed(ExecutorRole src, int32_t moduleType, const std::vector &acquireMsg) override; @@ -59,7 +59,6 @@ private: std::string description_; bool hasStarted_ = false; std::mutex mutex_; - ContextStopCallback stopCallback_ = nullptr; }; } // namespace UserAuth } // namespace UserIam diff --git a/services/context/inc/context.h b/services/context/inc/context.h index 4ed237ed1..c3ffc3961 100644 --- a/services/context/inc/context.h +++ b/services/context/inc/context.h @@ -41,21 +41,12 @@ enum ContextType { WIDGET_AUTH_CONTEXT, }; -class ContextCallback { -public: - virtual ~ContextCallback() = default; - virtual void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector &acquireMsg) const = 0; - virtual void OnResult(int32_t resultCode, const std::shared_ptr &finalResult) const = 0; -}; - class Context { public: using ContextStopCallback = std::function; - virtual ~Context() = default; virtual bool Start() = 0; virtual bool Stop() = 0; - virtual void SetContextStopCallback(ContextStopCallback callback) = 0; virtual uint64_t GetContextId() const = 0; virtual ContextType GetContextType() const = 0; virtual std::shared_ptr GetScheduleNode(uint64_t scheduleId) const = 0; diff --git a/services/context/inc/context_callback.h b/services/context/inc/context_callback.h new file mode 100644 index 000000000..e816da37d --- /dev/null +++ b/services/context/inc/context_callback.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed 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. + */ + +#ifndef IAM_CONTEXT_CALLBACK_H +#define IAM_CONTEXT_CALLBACK_H + +#include +#include +#include +#include +#include +#include +#include + +#include "context.h" +#include "user_auth_callback.h" +#include "user_idm_callback.h" + +namespace OHOS { +namespace UserIam { +namespace UserAuth { +class ContextCallbackNotifyListener : public Singleton { +public: + struct MetaData { + std::optional userId; + std::optional remainTime; + std::optional operationResult; + std::optional freezingTime; + std::optional sdkVersion; + std::optional callingUid; + std::optional operationType; + std::optional atl; + std::vector authTypeVector; + std::chrono::time_point startTime; + std::chrono::time_point endTime; + }; + using Notify = std::function; + void AddNotifier(const Notify ¬ify); + void Process(const MetaData &metaData); + +private: + std::vector notifierList_; +}; + +class ContextCallback { +public: + static std::shared_ptr Instance(sptr idmCallback); + static std::shared_ptr Instance(sptr userAuthCallback); + virtual ~ContextCallback() = default; + virtual void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector &acquireMsg) const = 0; + virtual void OnResult(int32_t resultCode, Attributes &finalResult) = 0; + virtual void SetTraceUserId(int32_t userId) = 0; + virtual void SetTraceRemainTime(int32_t remainTime) = 0; + virtual void SetTraceOperationResult(int32_t operationResult) = 0; + virtual void SetTraceFreezingTime(int32_t freezingTime) = 0; + virtual void SetTraceSdkVersion(int32_t version) = 0; + virtual void SetTraceCallingUid(uint64_t callingUid) = 0; + virtual void SetTraceAuthType(AuthType authType) = 0; + virtual void SetTraceOperationType(OperationType operationType) = 0; + virtual void SetTraceAuthTrustLevel(AuthTrustLevel atl) = 0; + virtual void SetCleaner(Context::ContextStopCallback callback) = 0; +}; +} // namespace UserAuth +} // namespace UserIam +} // namespace OHOS +#endif // IAM_CONTEXT_CALLBACK_H \ No newline at end of file diff --git a/services/context/inc/context_factory.h b/services/context/inc/context_factory.h index 0c660106c..7d1b72eaa 100644 --- a/services/context/inc/context_factory.h +++ b/services/context/inc/context_factory.h @@ -22,8 +22,7 @@ #include "singleton.h" #include "context.h" -#include "user_auth_callback.h" -#include "user_idm_callback.h" +#include "context_callback.h" namespace OHOS { namespace UserIam { @@ -31,11 +30,12 @@ namespace UserAuth { class ContextFactory : public DelayedSingleton { public: static std::shared_ptr CreateSimpleAuthContext(int32_t userId, const std::vector &challenge, - AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid, sptr &callback); + AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid, + const std::shared_ptr &callback); static std::shared_ptr CreateIdentifyContext(const std::vector &challenge, AuthType authType, - uint64_t callingUid, sptr &callback); + uint64_t callingUid, const std::shared_ptr &callback); static std::shared_ptr CreateEnrollContext(int32_t userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, uint64_t callingUid, const sptr &callback); + const std::vector &token, uint64_t callingUid, const std::shared_ptr &callback); static std::shared_ptr CreateWidgetAuthContext(std::shared_ptr callback); }; } // namespace UserAuth diff --git a/services/context/src/base_context.cpp b/services/context/src/base_context.cpp index 1d3ee9d51..491ca296b 100644 --- a/services/context/src/base_context.cpp +++ b/services/context/src/base_context.cpp @@ -69,11 +69,6 @@ std::shared_ptr BaseContext::GetScheduleNode(uint64_t scheduleId) return nullptr; } -void BaseContext::SetContextStopCallback(ContextStopCallback callback) -{ - stopCallback_ = callback; -}; - void BaseContext::OnScheduleStarted() { IAM_LOGI("%{public}s start", GetDescription()); @@ -89,9 +84,6 @@ void BaseContext::OnScheduleProcessed(ExecutorRole src, int32_t moduleType, cons void BaseContext::OnScheduleStoped(int32_t resultCode, const std::shared_ptr &finalResult) { OnResult(resultCode, finalResult); - if (stopCallback_ != nullptr) { - stopCallback_(); - } return; } diff --git a/services/context/src/context_callback_impl.cpp b/services/context/src/context_callback_impl.cpp index 2ed84e3a4..d1b5d4cd8 100644 --- a/services/context/src/context_callback_impl.cpp +++ b/services/context/src/context_callback_impl.cpp @@ -16,6 +16,7 @@ #include "iam_check.h" #include "iam_logger.h" +#include "iam_ptr.h" #define LOG_LABEL UserIAM::Common::LABEL_USER_AUTH_SA namespace OHOS { @@ -26,6 +27,7 @@ ContextCallbackImpl::ContextCallbackImpl(sptr idmCallback) : idmCal if (idmCallback_ == nullptr) { IAM_LOGE("idmCallback is nullptr, parameter is invalid"); } + metaData_.startTime = std::chrono::steady_clock::now(); } ContextCallbackImpl::ContextCallbackImpl(sptr userAuthCallback) : userAuthCallback_(userAuthCallback) @@ -33,6 +35,7 @@ ContextCallbackImpl::ContextCallbackImpl(sptr userAuthCallback if (userAuthCallback_ == nullptr) { IAM_LOGE("userAuthCallback is nullptr, parameter is invalid"); } + metaData_.startTime = std::chrono::steady_clock::now(); } void ContextCallbackImpl::onAcquireInfo(ExecutorRole src, int32_t moduleType, @@ -57,21 +60,108 @@ void ContextCallbackImpl::onAcquireInfo(ExecutorRole src, int32_t moduleType, } } -void ContextCallbackImpl::OnResult(int32_t resultCode, const std::shared_ptr &finalResult) const +void ContextCallbackImpl::OnResult(int32_t resultCode, Attributes &finalResult) { - IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr); + int32_t remainTime; + int32_t freezingTime; + metaData_.operationResult = resultCode; + if (finalResult.GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTime)) { + metaData_.remainTime = remainTime; + } + if (finalResult.GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime)) { + metaData_.freezingTime = freezingTime; + } + metaData_.endTime = std::chrono::steady_clock::now(); + if (idmCallback_ != nullptr) { - idmCallback_->OnResult(resultCode, *finalResult); + idmCallback_->OnResult(resultCode, finalResult); } if (userAuthCallback_ != nullptr) { int32_t userId; - auto isIdentify = finalResult->GetInt32Value(Attributes::ATTR_USER_ID, userId); + auto isIdentify = finalResult.GetInt32Value(Attributes::ATTR_USER_ID, userId); if (isIdentify) { - userAuthCallback_->OnIdentifyResult(resultCode, *finalResult); + userAuthCallback_->OnIdentifyResult(resultCode, finalResult); } else { - userAuthCallback_->OnAuthResult(resultCode, *finalResult); + userAuthCallback_->OnAuthResult(resultCode, finalResult); } } + + ContextCallbackNotifyListener::GetInstance().Process(metaData_); + if (stopCallback_ != nullptr) { + stopCallback_(); + } +} + +void ContextCallbackImpl::SetTraceUserId(int32_t userId) +{ + metaData_.userId = userId; +} + +void ContextCallbackImpl::SetTraceRemainTime(int32_t remainTime) +{ + metaData_.remainTime = remainTime; +} + +void ContextCallbackImpl::SetTraceOperationResult(int32_t operationResult) +{ + metaData_.operationResult = operationResult; +} + +void ContextCallbackImpl::SetTraceFreezingTime(int32_t freezingTime) +{ + metaData_.freezingTime = freezingTime; +} + +void ContextCallbackImpl::SetTraceSdkVersion(int32_t version) +{ + metaData_.sdkVersion = version; +} + +void ContextCallbackImpl::SetTraceCallingUid(uint64_t callingUid) +{ + metaData_.callingUid = callingUid; +} + +void ContextCallbackImpl::SetTraceAuthType(AuthType authType) +{ + metaData_.authTypeVector.push_back(authType); +} + +void ContextCallbackImpl::SetTraceOperationType(OperationType operationType) +{ + metaData_.operationType = operationType; +} + +void ContextCallbackImpl::SetTraceAuthTrustLevel(AuthTrustLevel atl) +{ + metaData_.atl = atl; +} + +void ContextCallbackImpl::SetCleaner(Context::ContextStopCallback callback) +{ + stopCallback_ = callback; +} + +void ContextCallbackNotifyListener::AddNotifier(const Notify ¬ify) +{ + notifierList_.emplace_back(notify); +} + +void ContextCallbackNotifyListener::Process(const MetaData &metaData) +{ + for (auto ¬ify : notifierList_) { + notify(metaData); + } +} + +std::shared_ptr ContextCallback::Instance(sptr idmCallback) +{ + return UserIAM::Common::MakeShared(idmCallback); +} + +std::shared_ptr ContextCallback::Instance(sptr userAuthCallback) +{ + return UserIAM::Common::MakeShared(userAuthCallback); } } // namespace UserAuth } // namespace UserIam diff --git a/services/context/src/context_callback_impl.h b/services/context/src/context_callback_impl.h index a9656e399..d88e35301 100644 --- a/services/context/src/context_callback_impl.h +++ b/services/context/src/context_callback_impl.h @@ -16,10 +16,7 @@ #ifndef CONTEXT_CALLBACK_IMPL_H #define CONTEXT_CALLBACK_IMPL_H -#include "context.h" - -#include "user_auth_callback.h" -#include "user_idm_callback.h" +#include "context_callback.h" namespace OHOS { namespace UserIam { @@ -30,11 +27,23 @@ public: explicit ContextCallbackImpl(sptr userAuthCallback); ~ContextCallbackImpl() override = default; void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector &acquireMsg) const override; - void OnResult(int32_t resultCode, const std::shared_ptr &finalResult) const override; + void OnResult(int32_t resultCode, Attributes &finalResult) override; + void SetTraceUserId(int32_t userId) override; + void SetTraceRemainTime(int32_t remainTime) override; + void SetTraceOperationResult(int32_t operationResult) override; + void SetTraceFreezingTime(int32_t freezingTime) override; + void SetTraceSdkVersion(int32_t version) override; + void SetTraceCallingUid(uint64_t callingUid) override; + void SetTraceAuthType(AuthType authType) override; + void SetTraceOperationType(OperationType operationType) override; + void SetTraceAuthTrustLevel(AuthTrustLevel atl) override; + void SetCleaner(Context::ContextStopCallback callback) override; private: sptr idmCallback_; sptr userAuthCallback_; + Context::ContextStopCallback stopCallback_ {nullptr}; + ContextCallbackNotifyListener::MetaData metaData_; }; } // namespace UserAuth } // namespace UserIam diff --git a/services/context/src/context_factory.cpp b/services/context/src/context_factory.cpp index 41118ccc1..12cb31938 100644 --- a/services/context/src/context_factory.cpp +++ b/services/context/src/context_factory.cpp @@ -33,7 +33,8 @@ namespace OHOS { namespace UserIam { namespace UserAuth { std::shared_ptr ContextFactory::CreateSimpleAuthContext(int32_t userId, const std::vector &challenge, - AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid, sptr &callback) + AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid, + const std::shared_ptr &callback) { IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, nullptr); uint64_t newContextId = ContextPool::GetNewContextId(); @@ -41,13 +42,11 @@ std::shared_ptr ContextFactory::CreateSimpleAuthContext(int32_t userId, IF_FALSE_LOGE_AND_RETURN_VAL(auth != nullptr, nullptr); auth->SetChallenge(challenge); auth->SetCallingUid(callingUid); - auto contextCallback = MakeShared(callback); - IF_FALSE_LOGE_AND_RETURN_VAL(contextCallback != nullptr, nullptr); - return MakeShared(newContextId, auth, contextCallback); + return MakeShared(newContextId, auth, callback); } std::shared_ptr ContextFactory::CreateIdentifyContext(const std::vector &challenge, AuthType authType, - uint64_t callingUid, sptr &callback) + uint64_t callingUid, const std::shared_ptr &callback) { IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, nullptr); uint64_t newContextId = ContextPool::GetNewContextId(); @@ -55,13 +54,11 @@ std::shared_ptr ContextFactory::CreateIdentifyContext(const std::vector IF_FALSE_LOGE_AND_RETURN_VAL(identify != nullptr, nullptr); identify->SetChallenge(challenge); identify->SetCallingUid(callingUid); - auto contextCallback = MakeShared(callback); - IF_FALSE_LOGE_AND_RETURN_VAL(contextCallback != nullptr, nullptr); - return MakeShared(newContextId, identify, contextCallback); + return MakeShared(newContextId, identify, callback); } std::shared_ptr ContextFactory::CreateEnrollContext(int32_t userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, uint64_t callingUid, const sptr &callback) + const std::vector &token, uint64_t callingUid, const std::shared_ptr &callback) { IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, nullptr); uint64_t newContextId = ContextPool::GetNewContextId(); @@ -70,9 +67,7 @@ std::shared_ptr ContextFactory::CreateEnrollContext(int32_t userId, Aut enroll->SetAuthToken(token); enroll->SetCallingUid(callingUid); enroll->SetPinSubType(pinSubType); - auto contextCallback = MakeShared(callback); - IF_FALSE_LOGE_AND_RETURN_VAL(contextCallback != nullptr, nullptr); - return MakeShared(newContextId, enroll, contextCallback); + return MakeShared(newContextId, enroll, callback); } std::shared_ptr ContextFactory::CreateWidgetAuthContext(std::shared_ptr callback) diff --git a/services/context/src/enroll_context.cpp b/services/context/src/enroll_context.cpp index 0cf3f513b..e93a008d0 100644 --- a/services/context/src/enroll_context.cpp +++ b/services/context/src/enroll_context.cpp @@ -108,9 +108,8 @@ void EnrollContext::InvokeResultCallback(int32_t resultCode, const uint64_t cred { IAM_LOGI("%{public}s start", GetDescription()); IF_FALSE_LOGE_AND_RETURN(callback_ != nullptr); - auto finalResult = MakeShared(); - IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr); - bool setCredIdRet = finalResult->SetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId); + Attributes finalResult; + bool setCredIdRet = finalResult.SetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId); IF_FALSE_LOGE_AND_RETURN(setCredIdRet == true); callback_->OnResult(resultCode, finalResult); IAM_LOGI("%{public}s invoke result callback success", GetDescription()); diff --git a/services/context/src/identify_context.cpp b/services/context/src/identify_context.cpp index 45d58307a..4c432fd38 100644 --- a/services/context/src/identify_context.cpp +++ b/services/context/src/identify_context.cpp @@ -97,14 +97,13 @@ void IdentifyContext::InvokeResultCallback(const Identification::IdentifyResultI { IAM_LOGI("%{public}s start", GetDescription()); IF_FALSE_LOGE_AND_RETURN(callback_ != nullptr); - auto finalResult = MakeShared(); - IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr); - bool setResultCodeRet = finalResult->SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result); + Attributes finalResult; + bool setResultCodeRet = finalResult.SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result); IF_FALSE_LOGE_AND_RETURN(setResultCodeRet == true); - bool setUserIdRet = finalResult->SetInt32Value(Attributes::ATTR_USER_ID, resultInfo.userId); + bool setUserIdRet = finalResult.SetInt32Value(Attributes::ATTR_USER_ID, resultInfo.userId); IF_FALSE_LOGE_AND_RETURN(setUserIdRet == true); if (resultInfo.token.size() != 0) { - bool setSignatureResult = finalResult->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token); + bool setSignatureResult = finalResult.SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token); IF_FALSE_LOGE_AND_RETURN(setSignatureResult == true); } diff --git a/services/context/src/simple_auth_context.cpp b/services/context/src/simple_auth_context.cpp index 71b66031f..f6cf1cf05 100644 --- a/services/context/src/simple_auth_context.cpp +++ b/services/context/src/simple_auth_context.cpp @@ -97,16 +97,15 @@ void SimpleAuthContext::InvokeResultCallback(const Authentication::AuthResultInf { IAM_LOGI("%{public}s start", GetDescription()); IF_FALSE_LOGE_AND_RETURN(callback_ != nullptr); - auto finalResult = MakeShared(); - IF_FALSE_LOGE_AND_RETURN(finalResult != nullptr); - bool setResultCodeRet = finalResult->SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result); + Attributes finalResult; + bool setResultCodeRet = finalResult.SetUint32Value(Attributes::ATTR_RESULT_CODE, resultInfo.result); IF_FALSE_LOGE_AND_RETURN(setResultCodeRet == true); - bool setFreezingTimeRet = finalResult->SetInt32Value(Attributes::ATTR_FREEZING_TIME, resultInfo.freezingTime); + bool setFreezingTimeRet = finalResult.SetInt32Value(Attributes::ATTR_FREEZING_TIME, resultInfo.freezingTime); IF_FALSE_LOGE_AND_RETURN(setFreezingTimeRet == true); - bool setUserIdRet = finalResult->SetInt32Value(Attributes::ATTR_REMAIN_TIMES, resultInfo.remainTimes); + bool setUserIdRet = finalResult.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, resultInfo.remainTimes); IF_FALSE_LOGE_AND_RETURN(setUserIdRet == true); if (resultInfo.token.size() != 0) { - bool setSignatureResult = finalResult->SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token); + bool setSignatureResult = finalResult.SetUint8ArrayValue(Attributes::ATTR_SIGNATURE, resultInfo.token); IF_FALSE_LOGE_AND_RETURN(setSignatureResult == true); } callback_->OnResult(resultInfo.result, finalResult); diff --git a/services/dfx/trace.cpp b/services/dfx/trace.cpp new file mode 100644 index 000000000..b07c5f7a0 --- /dev/null +++ b/services/dfx/trace.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed 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. + */ + +#include "trace.h" + +#include "iam_logger.h" + +#define LOG_LABEL UserIAM::Common::LABEL_USER_AUTH_SA + +namespace OHOS { +namespace UserIam { +namespace UserAuth { +Trace Trace::trace; + +Trace::Trace() +{ + // 注册 + ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessCredChangeEvent); + ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessUserAuthEvent); + ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessPinAuthEvent); +} + +Trace::~Trace() +{ +} + +void Trace::ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData) +{ + IAM_LOGI("start to process cred change event"); +} + +void Trace::ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData) +{ + IAM_LOGI("start to process user auth event"); +} + +void Trace::ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData) +{ + IAM_LOGI("start to process pin auth event"); +} +} // namespace UserAuth +} // namespace UserIam +} // namespace OHOS \ No newline at end of file diff --git a/services/dfx/trace.h b/services/dfx/trace.h new file mode 100644 index 000000000..48dd2b1b9 --- /dev/null +++ b/services/dfx/trace.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed 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. + */ + +#ifndef TRACE_H +#define TRACE_H + +#include "context_callback.h" + +namespace OHOS { +namespace UserIam { +namespace UserAuth { +class Trace { +public: + static void ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData); + static void ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); + static void ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); + Trace(); + ~Trace(); + +private: + static Trace trace; +}; +} // namespace UserAuth +} // namespace UserIam +} // namespace OHOS +#endif // TRACE_H \ No newline at end of file diff --git a/services/ipc/inc/user_idm_service.h b/services/ipc/inc/user_idm_service.h index 831e23fed..a5cec1b9f 100644 --- a/services/ipc/inc/user_idm_service.h +++ b/services/ipc/inc/user_idm_service.h @@ -39,7 +39,7 @@ public: const sptr &callback) override; int32_t GetSecInfo(std::optional userId, const sptr &callback) override; void AddCredential(std::optional userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, const sptr &callback) override; + const std::vector &token, const sptr &callback, bool isUpdate) override; void UpdateCredential(std::optional userId, AuthType authType, PinSubType pinSubType, const std::vector &token, const sptr &callback) override; int32_t Cancel(std::optional userId, const std::optional> &challenge) override; diff --git a/services/ipc/src/user_auth_service.cpp b/services/ipc/src/user_auth_service.cpp index 6fce2f5cc..a234ed7d8 100644 --- a/services/ipc/src/user_auth_service.cpp +++ b/services/ipc/src/user_auth_service.cpp @@ -22,6 +22,7 @@ #include "context_helper.h" #include "hdi_wrapper.h" #include "iam_logger.h" +#include "iam_ptr.h" #include "ipc_common.h" #include "result_code.h" #define LOG_LABEL UserIAM::Common::LABEL_USER_AUTH_SA @@ -192,41 +193,54 @@ uint64_t UserAuthService::AuthUser(std::optional userId, const std::vec IAM_LOGE("callback is nullptr"); return BAD_CONTEXT_ID; } + auto contextCallback = ContextCallback::Instance(callback); + if (contextCallback == nullptr) { + IAM_LOGE("failed to construct context callback"); + callback->OnAuthResult(GENERAL_ERROR, extraInfo); + return BAD_CONTEXT_ID; + } + if (authType == PIN) { + contextCallback->SetTraceOperationType(PIN_AUTH); + } else { + contextCallback->SetTraceOperationType(USER_AUTH); + } + auto callingUid = static_cast(this->GetCallingUid()); + contextCallback->SetTraceCallingUid(callingUid); + contextCallback->SetTraceAuthType(authType); + contextCallback->SetTraceAuthTrustLevel(authTrustLevel); + if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { + IAM_LOGE("get callingUserId failed"); + contextCallback->OnResult(FAIL, extraInfo); + return BAD_CONTEXT_ID; + } + contextCallback->SetTraceUserId(userId.value()); if (authTrustLevel < ATL1 || authTrustLevel > ATL4) { IAM_LOGE("authTrustLevel is not in correct range"); - callback->OnAuthResult(TRUST_LEVEL_NOT_SUPPORT, extraInfo); + contextCallback->OnResult(TRUST_LEVEL_NOT_SUPPORT, extraInfo); return BAD_CONTEXT_ID; } bool checkRet = !IpcCommon::CheckPermission(*this, ACCESS_USER_AUTH_INTERNAL_PERMISSION) && (authType == PIN || !IpcCommon::CheckPermission(*this, ACCESS_BIOMETRIC_PERMISSION)); if (checkRet) { IAM_LOGE("failed to check permission"); - callback->OnAuthResult(CHECK_PERMISSION_FAILED, extraInfo); + contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo); return BAD_CONTEXT_ID; } - if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { - IAM_LOGE("get callingUserId failed"); - callback->OnAuthResult(FAIL, extraInfo); - return BAD_CONTEXT_ID; - } - - auto callingUid = static_cast(this->GetCallingUid()); auto context = ContextFactory::CreateSimpleAuthContext(userId.value(), challenge, authType, authTrustLevel, - callingUid, callback); + callingUid, contextCallback); if (!ContextPool::Instance().Insert(context)) { IAM_LOGE("failed to insert context"); - callback->OnAuthResult(FAIL, extraInfo); + contextCallback->OnResult(FAIL, extraInfo); return BAD_CONTEXT_ID; } auto cleaner = ContextHelper::Cleaner(context); - context->SetContextStopCallback(cleaner); + contextCallback->SetCleaner(cleaner); if (!context->Start()) { IAM_LOGE("failed to start auth"); - callback->OnAuthResult(FAIL, extraInfo); - cleaner(); + contextCallback->OnResult(FAIL, extraInfo); return BAD_CONTEXT_ID; } return context->GetContextId(); @@ -236,33 +250,38 @@ uint64_t UserAuthService::Identify(const std::vector &challenge, AuthTy sptr &callback) { IAM_LOGI("start"); - Attributes extraInfo; if (callback == nullptr) { IAM_LOGE("callback is nullptr"); return BAD_CONTEXT_ID; } + Attributes extraInfo; + auto contextCallback = ContextCallback::Instance(callback); + if (contextCallback == nullptr) { + IAM_LOGE("failed to construct context callback"); + callback->OnIdentifyResult(GENERAL_ERROR, extraInfo); + return BAD_CONTEXT_ID; + } if (authType == PIN) { IAM_LOGE("pin not support"); - callback->OnIdentifyResult(TYPE_NOT_SUPPORT, extraInfo); + contextCallback->OnResult(TYPE_NOT_SUPPORT, extraInfo); return BAD_CONTEXT_ID; } auto callingUid = static_cast(this->GetCallingUid()); - auto context = ContextFactory::CreateIdentifyContext(challenge, authType, callingUid, callback); + auto context = ContextFactory::CreateIdentifyContext(challenge, authType, callingUid, contextCallback); if (!ContextPool::Instance().Insert(context)) { IAM_LOGE("failed to insert context"); - callback->OnIdentifyResult(FAIL, extraInfo); + contextCallback->OnResult(FAIL, extraInfo); return BAD_CONTEXT_ID; } auto cleaner = ContextHelper::Cleaner(context); - context->SetContextStopCallback(cleaner); + contextCallback->SetCleaner(cleaner); if (!context->Start()) { IAM_LOGE("failed to start identify"); - callback->OnIdentifyResult(FAIL, extraInfo); - cleaner(); + contextCallback->OnResult(FAIL, extraInfo); return BAD_CONTEXT_ID; } return context->GetContextId(); diff --git a/services/ipc/src/user_idm_service.cpp b/services/ipc/src/user_idm_service.cpp index 58cb66acc..945d3e052 100644 --- a/services/ipc/src/user_idm_service.cpp +++ b/services/ipc/src/user_idm_service.cpp @@ -21,6 +21,7 @@ #include "context_pool.h" #include "hdi_wrapper.h" #include "iam_logger.h" +#include "iam_ptr.h" #include "ipc_common.h" #include "resource_node_pool.h" #include "resource_node_utils.h" @@ -164,7 +165,7 @@ int32_t UserIdmService::GetSecInfo(std::optional userId, const sptr userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, const sptr &callback) + const std::vector &token, const sptr &callback, bool isUpdate) { if (callback == nullptr) { IAM_LOGE("callback is nullptr"); @@ -172,35 +173,47 @@ void UserIdmService::AddCredential(std::optional userId, AuthType authT } Attributes extraInfo; - - if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { - IAM_LOGE("failed to get userId"); - callback->OnResult(INVALID_PARAMETERS, extraInfo); + auto contextCallback = ContextCallback::Instance(callback); + if (contextCallback == nullptr) { + IAM_LOGE("failed to construct context callback"); + callback->OnResult(GENERAL_ERROR, extraInfo); return; } + if (isUpdate) { + contextCallback->SetTraceOperationType(UPDATE_CREDENTIAL); + } else { + contextCallback->SetTraceOperationType(ADD_CREDENTIAL); + } + uint64_t callingUid = static_cast(this->GetCallingUid()); + contextCallback->SetTraceAuthType(authType); + contextCallback->SetTraceCallingUid(callingUid); + if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { + IAM_LOGE("failed to get userId"); + contextCallback->OnResult(INVALID_PARAMETERS, extraInfo); + return; + } + contextCallback->SetTraceUserId(userId.value()); if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) { IAM_LOGE("failed to check permission"); - callback->OnResult(CHECK_PERMISSION_FAILED, extraInfo); + contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo); return; } - uint64_t callingUid = static_cast(this->GetCallingUid()); auto context = - ContextFactory::CreateEnrollContext(userId.value(), authType, pinSubType, token, callingUid, callback); + ContextFactory::CreateEnrollContext(userId.value(), authType, pinSubType, token, callingUid, contextCallback); if (!ContextPool::Instance().Insert(context)) { IAM_LOGE("failed to insert context"); - callback->OnResult(FAIL, extraInfo); + contextCallback->OnResult(FAIL, extraInfo); return; } auto cleaner = ContextHelper::Cleaner(context); - context->SetContextStopCallback(cleaner); + contextCallback->SetCleaner(cleaner); if (!context->Start()) { IAM_LOGE("failed to start enroll"); - callback->OnResult(FAIL, extraInfo); - cleaner(); + contextCallback->OnResult(FAIL, extraInfo); } } @@ -230,7 +243,7 @@ void UserIdmService::UpdateCredential(std::optional userId, AuthType au return; } - AddCredential(userId, authType, pinSubType, token, callback); + AddCredential(userId, authType, pinSubType, token, callback, true); } int32_t UserIdmService::Cancel(std::optional userId, const std::optional> &challenge) @@ -261,12 +274,21 @@ int32_t UserIdmService::EnforceDelUser(int32_t userId, const sptr & IAM_LOGE("callback is nullptr"); return INVALID_PARAMETERS; } + Attributes extraInfo; + auto contextCallback = ContextCallback::Instance(callback); + if (contextCallback == nullptr) { + IAM_LOGE("failed to construct context callback"); + callback->OnResult(GENERAL_ERROR, extraInfo); + return FAIL; + } + contextCallback->SetTraceOperationType(ENFORCE_DELETE_USER); + contextCallback->SetTraceUserId(userId); auto userInfo = UserIdmDatabase::Instance().GetSecUserInfo(userId); if (userInfo == nullptr) { IAM_LOGE("current userid %{public}d is not existed", userId); - callback->OnResult(INVALID_PARAMETERS, extraInfo); + contextCallback->OnResult(INVALID_PARAMETERS, extraInfo); return INVALID_PARAMETERS; } @@ -275,17 +297,23 @@ int32_t UserIdmService::EnforceDelUser(int32_t userId, const sptr & if (ret != SUCCESS) { IAM_LOGE("failed to enforce delete user"); static_cast(extraInfo.SetUint64Value(Attributes::ATTR_CREDENTIAL_ID, 0)); - callback->OnResult(ret, extraInfo); + contextCallback->OnResult(ret, extraInfo); return ret; } + for (const auto &credInfo : credInfos) { + if (credInfo != nullptr) { + contextCallback->SetTraceAuthType(credInfo->GetAuthType()); + } + } + ret = ResourceNodeUtils::NotifyExecutorToDeleteTemplates(credInfos); if (ret != SUCCESS) { IAM_LOGE("failed to delete executor info, error code : %{public}d", ret); } IAM_LOGI("delete user success"); - callback->OnResult(SUCCESS, extraInfo); + contextCallback->OnResult(SUCCESS, extraInfo); return SUCCESS; } @@ -298,15 +326,23 @@ void UserIdmService::DelUser(std::optional userId, const std::vectorOnResult(CHECK_PERMISSION_FAILED, extraInfo); + auto contextCallback = ContextCallback::Instance(callback); + if (contextCallback == nullptr) { + IAM_LOGE("failed to construct context callback"); + callback->OnResult(GENERAL_ERROR, extraInfo); return; } - + contextCallback->SetTraceOperationType(DELETE_USER); if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { IAM_LOGE("failed to get userId"); - callback->OnResult(INVALID_PARAMETERS, extraInfo); + contextCallback->OnResult(INVALID_PARAMETERS, extraInfo); + return; + } + contextCallback->SetTraceUserId(userId.value()); + + if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) { + IAM_LOGE("failed to check permission"); + contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo); return; } @@ -319,9 +355,14 @@ void UserIdmService::DelUser(std::optional userId, const std::vectorOnResult(ret, extraInfo); + contextCallback->OnResult(ret, extraInfo); return; } + for (const auto &credInfo : credInfos) { + if (credInfo != nullptr) { + contextCallback->SetTraceAuthType(credInfo->GetAuthType()); + } + } ret = ResourceNodeUtils::NotifyExecutorToDeleteTemplates(credInfos); if (ret != SUCCESS) { @@ -329,7 +370,7 @@ void UserIdmService::DelUser(std::optional userId, const std::vectorOnResult(ret, extraInfo); + contextCallback->OnResult(ret, extraInfo); } void UserIdmService::DelCredential(std::optional userId, uint64_t credentialId, @@ -341,15 +382,23 @@ void UserIdmService::DelCredential(std::optional userId, uint64_t crede } Attributes extraInfo; - if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) { - IAM_LOGE("failed to check permission"); - callback->OnResult(CHECK_PERMISSION_FAILED, extraInfo); + auto contextCallback = ContextCallback::Instance(callback); + if (contextCallback == nullptr) { + IAM_LOGE("failed to construct context callback"); + callback->OnResult(GENERAL_ERROR, extraInfo); return; } - + contextCallback->SetTraceOperationType(DELETE_CREDENTIAL); if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { IAM_LOGE("failed to get userId"); - callback->OnResult(INVALID_PARAMETERS, extraInfo); + contextCallback->OnResult(INVALID_PARAMETERS, extraInfo); + return; + } + contextCallback->SetTraceUserId(userId.value()); + + if (!IpcCommon::CheckPermission(*this, MANAGE_USER_IDM_PERMISSION)) { + IAM_LOGE("failed to check permission"); + contextCallback->OnResult(CHECK_PERMISSION_FAILED, extraInfo); return; } @@ -357,9 +406,12 @@ void UserIdmService::DelCredential(std::optional userId, uint64_t crede auto ret = UserIdmDatabase::Instance().DeleteCredentialInfo(userId.value(), credentialId, authToken, oldInfo); if (ret != SUCCESS) { IAM_LOGE("failed to delete CredentialInfo"); - callback->OnResult(ret, extraInfo); + contextCallback->OnResult(ret, extraInfo); return; } + if (oldInfo != nullptr) { + contextCallback->SetTraceAuthType(oldInfo->GetAuthType()); + } IAM_LOGI("delete credentialInfo success"); std::vector> list = {oldInfo}; @@ -368,7 +420,7 @@ void UserIdmService::DelCredential(std::optional userId, uint64_t crede IAM_LOGE("failed to delete executor info, error code : %{public}d", ret); } - callback->OnResult(ret, extraInfo); + contextCallback->OnResult(ret, extraInfo); } } // namespace UserAuth } // namespace UserIam diff --git a/services/ipc/src/user_idm_stub.cpp b/services/ipc/src/user_idm_stub.cpp index db84601de..4e1614b19 100644 --- a/services/ipc/src/user_idm_stub.cpp +++ b/services/ipc/src/user_idm_stub.cpp @@ -273,7 +273,8 @@ int32_t UserIdmStub::AddCredentialStub(MessageParcel &data, MessageParcel &reply IAM_LOGI("auth type is pin, clear token"); token.clear(); } - AddCredential(std::nullopt, static_cast(authType), static_cast(authSubType), token, callback); + AddCredential(std::nullopt, static_cast(authType), static_cast(authSubType), + token, callback, false); return SUCCESS; } @@ -315,7 +316,8 @@ int32_t UserIdmStub::AddCredentialByIdStub(MessageParcel &data, MessageParcel &r IAM_LOGI("auth type is pin, clear token"); token.clear(); } - AddCredential(userId, static_cast(authType), static_cast(authSubType), token, callback); + AddCredential(userId, static_cast(authType), static_cast(authSubType), + token, callback, false); return SUCCESS; } From cd9c47abcd7181b6599c567cbec1f7705e24bb17 Mon Sep 17 00:00:00 2001 From: youliang_1314 Date: Fri, 1 Jul 2022 11:53:54 +0800 Subject: [PATCH 2/7] update code Signed-off-by: youliang_1314 Change-Id: I2c85d40344d4d6d89da044120e302ec31a81b908 --- {services/dfx => dfx/inc}/trace.h | 6 ++-- {services/dfx => dfx/src}/trace.cpp | 1 - services/BUILD.gn | 4 +-- services/common_defines/types/iam_types.h | 10 ------- services/context/inc/context_callback.h | 16 ++++++++-- .../context/src/context_callback_impl.cpp | 29 ++++++++++--------- services/context/src/context_callback_impl.h | 5 ++-- services/ipc/src/user_auth_service.cpp | 9 ++---- services/ipc/src/user_idm_service.cpp | 17 ++++------- 9 files changed, 43 insertions(+), 54 deletions(-) rename {services/dfx => dfx/inc}/trace.h (98%) rename {services/dfx => dfx/src}/trace.cpp (97%) diff --git a/services/dfx/trace.h b/dfx/inc/trace.h similarity index 98% rename from services/dfx/trace.h rename to dfx/inc/trace.h index 48dd2b1b9..f0f518d5b 100644 --- a/services/dfx/trace.h +++ b/dfx/inc/trace.h @@ -23,14 +23,14 @@ namespace UserIam { namespace UserAuth { class Trace { public: - static void ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData); - static void ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); - static void ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); Trace(); ~Trace(); private: static Trace trace; + static void ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData); + static void ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); + static void ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); }; } // namespace UserAuth } // namespace UserIam diff --git a/services/dfx/trace.cpp b/dfx/src/trace.cpp similarity index 97% rename from services/dfx/trace.cpp rename to dfx/src/trace.cpp index b07c5f7a0..682960ca7 100644 --- a/services/dfx/trace.cpp +++ b/dfx/src/trace.cpp @@ -26,7 +26,6 @@ Trace Trace::trace; Trace::Trace() { - // 注册 ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessCredChangeEvent); ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessUserAuthEvent); ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessPinAuthEvent); diff --git a/services/BUILD.gn b/services/BUILD.gn index 680ab8060..974654c8a 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -27,10 +27,10 @@ ohos_shared_library("userauthservice") { "core/src", "context/inc", "ipc/inc", - "dfx", "common_defines/types", "common_defines/interfaces", "//base/useriam/user_auth_framework/common/utils", + "//base/useriam/user_auth_framework/dfx/inc", ] remove_configs = [ "//build/config/compiler:no_exceptions" ] @@ -75,7 +75,7 @@ ohos_shared_library("userauthservice") { "ipc/src/user_idm_callback_proxy.cpp", "ipc/src/user_idm_service.cpp", "ipc/src/user_idm_stub.cpp", - "dfx/trace.cpp", + "//base/useriam/user_auth_framework/dfx/src/trace.cpp", ] deps = [ diff --git a/services/common_defines/types/iam_types.h b/services/common_defines/types/iam_types.h index e2ebe00eb..69d25c449 100644 --- a/services/common_defines/types/iam_types.h +++ b/services/common_defines/types/iam_types.h @@ -62,16 +62,6 @@ enum ScheduleMode : uint32_t { IDENTIFY = 2, }; -enum OperationType : uint32_t { - ADD_CREDENTIAL = 0, - DELETE_CREDENTIAL = 1, - DELETE_USER = 2, - ENFORCE_DELETE_USER = 3, - UPDATE_CREDENTIAL = 4, - USER_AUTH = 5, - PIN_AUTH = 6, -}; - enum PropertyMode : uint32_t { PROPERTY_MODE_DEL = 0, PROPERTY_MODE_GET = 1, diff --git a/services/context/inc/context_callback.h b/services/context/inc/context_callback.h index e816da37d..9ed15247e 100644 --- a/services/context/inc/context_callback.h +++ b/services/context/inc/context_callback.h @@ -31,6 +31,16 @@ namespace OHOS { namespace UserIam { namespace UserAuth { +enum OperationType : uint32_t { + TRACE_ADD_CREDENTIAL = 0, + TRACE_DELETE_CREDENTIAL = 1, + TRACE_DELETE_USER = 2, + TRACE_ENFORCE_DELETE_USER = 3, + TRACE_UPDATE_CREDENTIAL = 4, + TRACE_AUTH_USER = 5, + TRACE_IDENTIFY = 6, +}; + class ContextCallbackNotifyListener : public Singleton { public: struct MetaData { @@ -56,8 +66,9 @@ private: class ContextCallback { public: - static std::shared_ptr Instance(sptr idmCallback); - static std::shared_ptr Instance(sptr userAuthCallback); + static std::shared_ptr NewInstance(sptr idmCallback, OperationType operationType); + static std::shared_ptr NewInstance(sptr userAuthCallback, + OperationType operationType); virtual ~ContextCallback() = default; virtual void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector &acquireMsg) const = 0; virtual void OnResult(int32_t resultCode, Attributes &finalResult) = 0; @@ -68,7 +79,6 @@ public: virtual void SetTraceSdkVersion(int32_t version) = 0; virtual void SetTraceCallingUid(uint64_t callingUid) = 0; virtual void SetTraceAuthType(AuthType authType) = 0; - virtual void SetTraceOperationType(OperationType operationType) = 0; virtual void SetTraceAuthTrustLevel(AuthTrustLevel atl) = 0; virtual void SetCleaner(Context::ContextStopCallback callback) = 0; }; diff --git a/services/context/src/context_callback_impl.cpp b/services/context/src/context_callback_impl.cpp index d1b5d4cd8..dfee6f778 100644 --- a/services/context/src/context_callback_impl.cpp +++ b/services/context/src/context_callback_impl.cpp @@ -22,19 +22,23 @@ namespace OHOS { namespace UserIam { namespace UserAuth { -ContextCallbackImpl::ContextCallbackImpl(sptr idmCallback) : idmCallback_(idmCallback) +ContextCallbackImpl::ContextCallbackImpl(sptr idmCallback, OperationType operationType) + : idmCallback_(idmCallback) { if (idmCallback_ == nullptr) { IAM_LOGE("idmCallback is nullptr, parameter is invalid"); } + metaData_.operationType = operationType; metaData_.startTime = std::chrono::steady_clock::now(); } -ContextCallbackImpl::ContextCallbackImpl(sptr userAuthCallback) : userAuthCallback_(userAuthCallback) +ContextCallbackImpl::ContextCallbackImpl(sptr userAuthCallback, OperationType operationType) + : userAuthCallback_(userAuthCallback) { if (userAuthCallback_ == nullptr) { IAM_LOGE("userAuthCallback is nullptr, parameter is invalid"); } + metaData_.operationType = operationType; metaData_.startTime = std::chrono::steady_clock::now(); } @@ -127,11 +131,6 @@ void ContextCallbackImpl::SetTraceAuthType(AuthType authType) metaData_.authTypeVector.push_back(authType); } -void ContextCallbackImpl::SetTraceOperationType(OperationType operationType) -{ - metaData_.operationType = operationType; -} - void ContextCallbackImpl::SetTraceAuthTrustLevel(AuthTrustLevel atl) { metaData_.atl = atl; @@ -149,19 +148,23 @@ void ContextCallbackNotifyListener::AddNotifier(const Notify ¬ify) void ContextCallbackNotifyListener::Process(const MetaData &metaData) { - for (auto ¬ify : notifierList_) { - notify(metaData); + for (const auto ¬ify : notifierList_) { + if (notify != nullptr) { + notify(metaData); + } } } -std::shared_ptr ContextCallback::Instance(sptr idmCallback) +std::shared_ptr ContextCallback::NewInstance(sptr idmCallback, + OperationType operationType) { - return UserIAM::Common::MakeShared(idmCallback); + return UserIAM::Common::MakeShared(idmCallback, operationType); } -std::shared_ptr ContextCallback::Instance(sptr userAuthCallback) +std::shared_ptr ContextCallback::NewInstance(sptr userAuthCallback, + OperationType operationType) { - return UserIAM::Common::MakeShared(userAuthCallback); + return UserIAM::Common::MakeShared(userAuthCallback, operationType); } } // namespace UserAuth } // namespace UserIam diff --git a/services/context/src/context_callback_impl.h b/services/context/src/context_callback_impl.h index d88e35301..74addbf97 100644 --- a/services/context/src/context_callback_impl.h +++ b/services/context/src/context_callback_impl.h @@ -23,8 +23,8 @@ namespace UserIam { namespace UserAuth { class ContextCallbackImpl : public ContextCallback, public NoCopyable { public: - explicit ContextCallbackImpl(sptr idmCallback); - explicit ContextCallbackImpl(sptr userAuthCallback); + explicit ContextCallbackImpl(sptr idmCallback, OperationType operationType); + explicit ContextCallbackImpl(sptr userAuthCallback, OperationType operationType); ~ContextCallbackImpl() override = default; void onAcquireInfo(ExecutorRole src, int32_t moduleType, const std::vector &acquireMsg) const override; void OnResult(int32_t resultCode, Attributes &finalResult) override; @@ -35,7 +35,6 @@ public: void SetTraceSdkVersion(int32_t version) override; void SetTraceCallingUid(uint64_t callingUid) override; void SetTraceAuthType(AuthType authType) override; - void SetTraceOperationType(OperationType operationType) override; void SetTraceAuthTrustLevel(AuthTrustLevel atl) override; void SetCleaner(Context::ContextStopCallback callback) override; diff --git a/services/ipc/src/user_auth_service.cpp b/services/ipc/src/user_auth_service.cpp index a234ed7d8..4bea99db3 100644 --- a/services/ipc/src/user_auth_service.cpp +++ b/services/ipc/src/user_auth_service.cpp @@ -193,17 +193,12 @@ uint64_t UserAuthService::AuthUser(std::optional userId, const std::vec IAM_LOGE("callback is nullptr"); return BAD_CONTEXT_ID; } - auto contextCallback = ContextCallback::Instance(callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER); if (contextCallback == nullptr) { IAM_LOGE("failed to construct context callback"); callback->OnAuthResult(GENERAL_ERROR, extraInfo); return BAD_CONTEXT_ID; } - if (authType == PIN) { - contextCallback->SetTraceOperationType(PIN_AUTH); - } else { - contextCallback->SetTraceOperationType(USER_AUTH); - } auto callingUid = static_cast(this->GetCallingUid()); contextCallback->SetTraceCallingUid(callingUid); contextCallback->SetTraceAuthType(authType); @@ -256,7 +251,7 @@ uint64_t UserAuthService::Identify(const std::vector &challenge, AuthTy return BAD_CONTEXT_ID; } Attributes extraInfo; - auto contextCallback = ContextCallback::Instance(callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_IDENTIFY); if (contextCallback == nullptr) { IAM_LOGE("failed to construct context callback"); callback->OnIdentifyResult(GENERAL_ERROR, extraInfo); diff --git a/services/ipc/src/user_idm_service.cpp b/services/ipc/src/user_idm_service.cpp index 945d3e052..3941642ff 100644 --- a/services/ipc/src/user_idm_service.cpp +++ b/services/ipc/src/user_idm_service.cpp @@ -173,17 +173,13 @@ void UserIdmService::AddCredential(std::optional userId, AuthType authT } Attributes extraInfo; - auto contextCallback = ContextCallback::Instance(callback); + auto contextCallback = ContextCallback::NewInstance(callback, + isUpdate ? TRACE_UPDATE_CREDENTIAL : TRACE_ADD_CREDENTIAL); if (contextCallback == nullptr) { IAM_LOGE("failed to construct context callback"); callback->OnResult(GENERAL_ERROR, extraInfo); return; } - if (isUpdate) { - contextCallback->SetTraceOperationType(UPDATE_CREDENTIAL); - } else { - contextCallback->SetTraceOperationType(ADD_CREDENTIAL); - } uint64_t callingUid = static_cast(this->GetCallingUid()); contextCallback->SetTraceAuthType(authType); contextCallback->SetTraceCallingUid(callingUid); @@ -276,13 +272,12 @@ int32_t UserIdmService::EnforceDelUser(int32_t userId, const sptr & } Attributes extraInfo; - auto contextCallback = ContextCallback::Instance(callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ENFORCE_DELETE_USER); if (contextCallback == nullptr) { IAM_LOGE("failed to construct context callback"); callback->OnResult(GENERAL_ERROR, extraInfo); return FAIL; } - contextCallback->SetTraceOperationType(ENFORCE_DELETE_USER); contextCallback->SetTraceUserId(userId); auto userInfo = UserIdmDatabase::Instance().GetSecUserInfo(userId); @@ -326,13 +321,12 @@ void UserIdmService::DelUser(std::optional userId, const std::vectorOnResult(GENERAL_ERROR, extraInfo); return; } - contextCallback->SetTraceOperationType(DELETE_USER); if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { IAM_LOGE("failed to get userId"); contextCallback->OnResult(INVALID_PARAMETERS, extraInfo); @@ -382,13 +376,12 @@ void UserIdmService::DelCredential(std::optional userId, uint64_t crede } Attributes extraInfo; - auto contextCallback = ContextCallback::Instance(callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_DELETE_CREDENTIAL); if (contextCallback == nullptr) { IAM_LOGE("failed to construct context callback"); callback->OnResult(GENERAL_ERROR, extraInfo); return; } - contextCallback->SetTraceOperationType(DELETE_CREDENTIAL); if (IpcCommon::GetCallingUserId(*this, userId) != SUCCESS) { IAM_LOGE("failed to get userId"); contextCallback->OnResult(INVALID_PARAMETERS, extraInfo); From 85ce650ba4876abbef03d60b8cef22e673e68315 Mon Sep 17 00:00:00 2001 From: youliang_1314 Date: Fri, 1 Jul 2022 14:58:24 +0800 Subject: [PATCH 3/7] update code Signed-off-by: youliang_1314 Change-Id: I32c6f7752ef02dbbbd1e71c8a175d2a5653fe4b2 --- dfx/inc/trace.h | 1 + dfx/src/trace.cpp | 26 +++++++++++++++++++ services/context/inc/context_callback.h | 7 +++-- .../context/src/context_callback_impl.cpp | 7 +---- services/context/src/context_callback_impl.h | 1 - services/ipc/src/user_idm_service.cpp | 11 -------- 6 files changed, 31 insertions(+), 22 deletions(-) diff --git a/dfx/inc/trace.h b/dfx/inc/trace.h index f0f518d5b..91d9c63e6 100644 --- a/dfx/inc/trace.h +++ b/dfx/inc/trace.h @@ -31,6 +31,7 @@ private: static void ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData); static void ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); static void ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); + static void ProcessDelUserEvent(const ContextCallbackNotifyListener::MetaData &metaData); }; } // namespace UserAuth } // namespace UserIam diff --git a/dfx/src/trace.cpp b/dfx/src/trace.cpp index 682960ca7..2a264d27a 100644 --- a/dfx/src/trace.cpp +++ b/dfx/src/trace.cpp @@ -29,6 +29,7 @@ Trace::Trace() ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessCredChangeEvent); ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessUserAuthEvent); ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessPinAuthEvent); + ContextCallbackNotifyListener::GetInstance().AddNotifier(ProcessDelUserEvent); } Trace::~Trace() @@ -37,18 +38,43 @@ Trace::~Trace() void Trace::ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData) { + OperationType type = metaData.operationType; + bool checkRet = type == TRACE_ADD_CREDENTIAL || type == TRACE_DELETE_CREDENTIAL || type == TRACE_UPDATE_CREDENTIAL; + if (!checkRet) { + return; + } IAM_LOGI("start to process cred change event"); } void Trace::ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData) { + bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() + && metaData.authType != PIN; + if (!checkRet) { + return; + } IAM_LOGI("start to process user auth event"); } void Trace::ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData) { + bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() + && metaData.authType == PIN; + if (!checkRet) { + return; + } IAM_LOGI("start to process pin auth event"); } + +void Trace::ProcessDelUserEvent(const ContextCallbackNotifyListener::MetaData &metaData) +{ + OperationType type = metaData.operationType; + bool checkRet = type == TRACE_DELETE_USER || type == TRACE_ENFORCE_DELETE_USER; + if (!checkRet) { + return; + } + IAM_LOGI("start to process del user event"); +} } // namespace UserAuth } // namespace UserIam } // namespace OHOS \ No newline at end of file diff --git a/services/context/inc/context_callback.h b/services/context/inc/context_callback.h index 9ed15247e..0abd854ca 100644 --- a/services/context/inc/context_callback.h +++ b/services/context/inc/context_callback.h @@ -44,15 +44,15 @@ enum OperationType : uint32_t { class ContextCallbackNotifyListener : public Singleton { public: struct MetaData { + OperationType operationType; + int32_t operationResult; std::optional userId; std::optional remainTime; - std::optional operationResult; std::optional freezingTime; std::optional sdkVersion; std::optional callingUid; - std::optional operationType; std::optional atl; - std::vector authTypeVector; + std::optional authType; std::chrono::time_point startTime; std::chrono::time_point endTime; }; @@ -74,7 +74,6 @@ public: virtual void OnResult(int32_t resultCode, Attributes &finalResult) = 0; virtual void SetTraceUserId(int32_t userId) = 0; virtual void SetTraceRemainTime(int32_t remainTime) = 0; - virtual void SetTraceOperationResult(int32_t operationResult) = 0; virtual void SetTraceFreezingTime(int32_t freezingTime) = 0; virtual void SetTraceSdkVersion(int32_t version) = 0; virtual void SetTraceCallingUid(uint64_t callingUid) = 0; diff --git a/services/context/src/context_callback_impl.cpp b/services/context/src/context_callback_impl.cpp index dfee6f778..cf7f9c293 100644 --- a/services/context/src/context_callback_impl.cpp +++ b/services/context/src/context_callback_impl.cpp @@ -106,11 +106,6 @@ void ContextCallbackImpl::SetTraceRemainTime(int32_t remainTime) metaData_.remainTime = remainTime; } -void ContextCallbackImpl::SetTraceOperationResult(int32_t operationResult) -{ - metaData_.operationResult = operationResult; -} - void ContextCallbackImpl::SetTraceFreezingTime(int32_t freezingTime) { metaData_.freezingTime = freezingTime; @@ -128,7 +123,7 @@ void ContextCallbackImpl::SetTraceCallingUid(uint64_t callingUid) void ContextCallbackImpl::SetTraceAuthType(AuthType authType) { - metaData_.authTypeVector.push_back(authType); + metaData_.authType = authType; } void ContextCallbackImpl::SetTraceAuthTrustLevel(AuthTrustLevel atl) diff --git a/services/context/src/context_callback_impl.h b/services/context/src/context_callback_impl.h index 74addbf97..2bdb5ed33 100644 --- a/services/context/src/context_callback_impl.h +++ b/services/context/src/context_callback_impl.h @@ -30,7 +30,6 @@ public: void OnResult(int32_t resultCode, Attributes &finalResult) override; void SetTraceUserId(int32_t userId) override; void SetTraceRemainTime(int32_t remainTime) override; - void SetTraceOperationResult(int32_t operationResult) override; void SetTraceFreezingTime(int32_t freezingTime) override; void SetTraceSdkVersion(int32_t version) override; void SetTraceCallingUid(uint64_t callingUid) override; diff --git a/services/ipc/src/user_idm_service.cpp b/services/ipc/src/user_idm_service.cpp index 3941642ff..a10d051ef 100644 --- a/services/ipc/src/user_idm_service.cpp +++ b/services/ipc/src/user_idm_service.cpp @@ -296,12 +296,6 @@ int32_t UserIdmService::EnforceDelUser(int32_t userId, const sptr & return ret; } - for (const auto &credInfo : credInfos) { - if (credInfo != nullptr) { - contextCallback->SetTraceAuthType(credInfo->GetAuthType()); - } - } - ret = ResourceNodeUtils::NotifyExecutorToDeleteTemplates(credInfos); if (ret != SUCCESS) { IAM_LOGE("failed to delete executor info, error code : %{public}d", ret); @@ -352,11 +346,6 @@ void UserIdmService::DelUser(std::optional userId, const std::vectorOnResult(ret, extraInfo); return; } - for (const auto &credInfo : credInfos) { - if (credInfo != nullptr) { - contextCallback->SetTraceAuthType(credInfo->GetAuthType()); - } - } ret = ResourceNodeUtils::NotifyExecutorToDeleteTemplates(credInfos); if (ret != SUCCESS) { From b02357a4fe8f999cbf7034a826bd130693aa7ccd Mon Sep 17 00:00:00 2001 From: youliang_1314 Date: Fri, 1 Jul 2022 16:25:05 +0800 Subject: [PATCH 4/7] fix UT code Signed-off-by: youliang_1314 Change-Id: I1fa4a19b1118b5723f1d5d6755ec595212a51f8a --- services/BUILD.gn | 2 +- .../context/src/context_callback_impl.cpp | 14 +++++----- .../user_idm_service_fuzzer.cpp | 2 +- test/unittest/services/mocks/mock_context.h | 12 +++++++-- .../services/mocks/mock_user_idm_service.h | 4 +-- .../src/context_callback_impl_test.cpp | 26 +++++++++---------- .../services/src/context_factory_test.cpp | 22 ++++++++++------ .../services/src/enroll_context_test.cpp | 12 ++++----- .../services/src/identify_context_test.cpp | 16 ++++++------ .../services/src/simple_auth_context_test.cpp | 18 ++++++------- .../services/src/user_idm_stub_test.cpp | 8 +++--- 11 files changed, 75 insertions(+), 61 deletions(-) diff --git a/services/BUILD.gn b/services/BUILD.gn index 974654c8a..6e0ed60ed 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -36,6 +36,7 @@ ohos_shared_library("userauthservice") { remove_configs = [ "//build/config/compiler:no_exceptions" ] sources = [ + "//base/useriam/user_auth_framework/dfx/src/trace.cpp", "base/src/finite_state_machine_builder.cpp", "base/src/finite_state_machine_impl.cpp", "base/src/hdi_wrapper.cpp", @@ -75,7 +76,6 @@ ohos_shared_library("userauthservice") { "ipc/src/user_idm_callback_proxy.cpp", "ipc/src/user_idm_service.cpp", "ipc/src/user_idm_stub.cpp", - "//base/useriam/user_auth_framework/dfx/src/trace.cpp", ] deps = [ diff --git a/services/context/src/context_callback_impl.cpp b/services/context/src/context_callback_impl.cpp index cf7f9c293..7633ab3f0 100644 --- a/services/context/src/context_callback_impl.cpp +++ b/services/context/src/context_callback_impl.cpp @@ -25,9 +25,6 @@ namespace UserAuth { ContextCallbackImpl::ContextCallbackImpl(sptr idmCallback, OperationType operationType) : idmCallback_(idmCallback) { - if (idmCallback_ == nullptr) { - IAM_LOGE("idmCallback is nullptr, parameter is invalid"); - } metaData_.operationType = operationType; metaData_.startTime = std::chrono::steady_clock::now(); } @@ -35,9 +32,6 @@ ContextCallbackImpl::ContextCallbackImpl(sptr idmCallback, Operatio ContextCallbackImpl::ContextCallbackImpl(sptr userAuthCallback, OperationType operationType) : userAuthCallback_(userAuthCallback) { - if (userAuthCallback_ == nullptr) { - IAM_LOGE("userAuthCallback is nullptr, parameter is invalid"); - } metaData_.operationType = operationType; metaData_.startTime = std::chrono::steady_clock::now(); } @@ -153,12 +147,20 @@ void ContextCallbackNotifyListener::Process(const MetaData &metaData) std::shared_ptr ContextCallback::NewInstance(sptr idmCallback, OperationType operationType) { + if (idmCallback == nullptr) { + IAM_LOGE("idmCallback is nullptr, parameter is invalid"); + return nullptr; + } return UserIAM::Common::MakeShared(idmCallback, operationType); } std::shared_ptr ContextCallback::NewInstance(sptr userAuthCallback, OperationType operationType) { + if (userAuthCallback == nullptr) { + IAM_LOGE("userAuthCallback is nullptr, parameter is invalid"); + return nullptr; + } return UserIAM::Common::MakeShared(userAuthCallback, operationType); } } // namespace UserAuth diff --git a/test/fuzztest/services/useridmservice_fuzzer/user_idm_service_fuzzer.cpp b/test/fuzztest/services/useridmservice_fuzzer/user_idm_service_fuzzer.cpp index 933875fb1..097f36875 100644 --- a/test/fuzztest/services/useridmservice_fuzzer/user_idm_service_fuzzer.cpp +++ b/test/fuzztest/services/useridmservice_fuzzer/user_idm_service_fuzzer.cpp @@ -176,7 +176,7 @@ void FuzzAddCredential(Parcel &parcel) std::vector token; FillFuzzUint8Vector(parcel, token); sptr callback = GetFuzzIdmCallback(parcel); - g_UserIdmService.AddCredential(userId, authType, pinSubType, token, callback); + g_UserIdmService.AddCredential(userId, authType, pinSubType, token, callback, false); IAM_LOGI("end"); } diff --git a/test/unittest/services/mocks/mock_context.h b/test/unittest/services/mocks/mock_context.h index 8d238c20e..bf64be6d5 100644 --- a/test/unittest/services/mocks/mock_context.h +++ b/test/unittest/services/mocks/mock_context.h @@ -20,6 +20,7 @@ #include #include "context.h" +#include "context_callback.h" #include "iam_ptr.h" #include "mock_schedule_node.h" @@ -31,14 +32,21 @@ public: virtual ~MockContextCallback() = default; MOCK_CONST_METHOD3( onAcquireInfo, void(ExecutorRole src, int32_t moduleType, const std::vector &acquireMsg)); - MOCK_CONST_METHOD2(OnResult, void(int32_t resultCode, const std::shared_ptr &finalResult)); + MOCK_METHOD2(OnResult, void(int32_t resultCode, Attributes &finalResult)); + MOCK_METHOD1(SetTraceUserId, void(int32_t userId)); + MOCK_METHOD1(SetTraceRemainTime, void(int32_t remainTime)); + MOCK_METHOD1(SetTraceFreezingTime, void(int32_t freezingTime)); + MOCK_METHOD1(SetTraceSdkVersion, void(int32_t version)); + MOCK_METHOD1(SetTraceCallingUid, void(uint64_t callingUid)); + MOCK_METHOD1(SetTraceAuthType, void(AuthType authType)); + MOCK_METHOD1(SetTraceAuthTrustLevel, void(AuthTrustLevel atl)); + MOCK_METHOD1(SetCleaner, void(Context::ContextStopCallback callback)); }; class MockContext final : public Context { public: MOCK_METHOD0(Start, bool()); MOCK_METHOD0(Stop, bool()); - MOCK_METHOD1(SetContextStopCallback, void(ContextStopCallback callback)); MOCK_CONST_METHOD0(GetContextId, uint64_t()); MOCK_CONST_METHOD0(GetContextType, ContextType()); MOCK_CONST_METHOD1(GetScheduleNode, std::shared_ptr(uint64_t scheduleId)); diff --git a/test/unittest/services/mocks/mock_user_idm_service.h b/test/unittest/services/mocks/mock_user_idm_service.h index f55a5a536..577d995b8 100644 --- a/test/unittest/services/mocks/mock_user_idm_service.h +++ b/test/unittest/services/mocks/mock_user_idm_service.h @@ -31,8 +31,8 @@ public: int32_t(std::optional userId, AuthType authType, const sptr &callback)); MOCK_METHOD2(GetSecInfo, int32_t(std::optional userId, const sptr &callback)); - MOCK_METHOD5(AddCredential, void(std::optional userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, const sptr &callback)); + MOCK_METHOD6(AddCredential, void(std::optional userId, AuthType authType, PinSubType pinSubType, + const std::vector &token, const sptr &callback, bool isUpdate)); MOCK_METHOD5(UpdateCredential, void(std::optional userId, AuthType authType, PinSubType pinSubType, const std::vector &token, const sptr &callback)); MOCK_METHOD2(Cancel, int32_t(std::optional userId, const std::optional> &challenge)); diff --git a/test/unittest/services/src/context_callback_impl_test.cpp b/test/unittest/services/src/context_callback_impl_test.cpp index a9c4093e7..548598a93 100644 --- a/test/unittest/services/src/context_callback_impl_test.cpp +++ b/test/unittest/services/src/context_callback_impl_test.cpp @@ -57,24 +57,22 @@ void ContextCallbackImplTest::TearDown() HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuthNull, TestSize.Level1) { - sptr callback = nullptr; - auto contextCallback = MakeShared(callback); + sptr callback = new (nothrow) MockUserAuthCallback(); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL); ASSERT_NE(contextCallback, nullptr); - auto testAttr = MakeShared(); - ASSERT_TRUE(testAttr != nullptr); + Attributes attr; contextCallback->onAcquireInfo(static_cast(0), 0, {}); - contextCallback->OnResult(0, testAttr); + contextCallback->OnResult(0, attr); } HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmNull, TestSize.Level1) { - sptr callback = nullptr; - auto contextCallback = MakeShared(callback); + sptr callback = new (nothrow) MockIdmCallback(); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL); ASSERT_NE(contextCallback, nullptr); - auto testAttr = MakeShared(); - ASSERT_TRUE(testAttr != nullptr); + Attributes attr; contextCallback->onAcquireInfo(static_cast(0), 0, {}); - contextCallback->OnResult(0, testAttr); + contextCallback->OnResult(0, attr); } HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuth, TestSize.Level1) @@ -92,10 +90,10 @@ HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserAuth, TestSize.Level1) EXPECT_TRUE(&reqRet == testAttr.get()); }); sptr callback = mockCallback; - auto contextCallback = MakeShared(callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL); ASSERT_NE(contextCallback, nullptr); contextCallback->onAcquireInfo(static_cast(0), 0, {}); - contextCallback->OnResult(testResult, testAttr); + contextCallback->OnResult(testResult, *testAttr); } HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmOnResult, TestSize.Level1) @@ -113,10 +111,10 @@ HWTEST_F(ContextCallbackImplTest, ContextCallbackImplUserIdmOnResult, TestSize.L EXPECT_TRUE(&reqRet == testAttr.get()); }); sptr callback = mockCallback; - auto contextCallback = MakeShared(callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL); ASSERT_NE(contextCallback, nullptr); contextCallback->onAcquireInfo(static_cast(0), 0, {}); - contextCallback->OnResult(testResult, testAttr); + contextCallback->OnResult(testResult, *testAttr); } } // namespace UserAuth } // namespace UserIam diff --git a/test/unittest/services/src/context_factory_test.cpp b/test/unittest/services/src/context_factory_test.cpp index 793590391..56555a79c 100644 --- a/test/unittest/services/src/context_factory_test.cpp +++ b/test/unittest/services/src/context_factory_test.cpp @@ -58,8 +58,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateSimpleAuth_001, TestSize.Level1 std::vector challenge; sptr callback = new (nothrow) MockUserAuthCallback(); ASSERT_NE(callback, nullptr); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER); auto context = factory->CreateSimpleAuthContext( - 0, challenge, static_cast(0), static_cast(0), 0, callback); + 0, challenge, static_cast(0), static_cast(0), 0, contextCallback); ASSERT_NE(context, nullptr); EXPECT_NE(context->GetContextId(), 0U); ASSERT_EQ(context->GetContextType(), CONTEXT_SIMPLE_AUTH); @@ -72,8 +73,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateSimpleAuth_002, TestSize.Level1 std::vector challenge; // Error: callback is null sptr callback = nullptr; + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_AUTH_USER); auto context = factory->CreateSimpleAuthContext( - 0, challenge, static_cast(0), static_cast(0), 0, callback); + 0, challenge, static_cast(0), static_cast(0), 0, contextCallback); ASSERT_EQ(context, nullptr); } @@ -84,7 +86,8 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateIdentify_001, TestSize.Level1) std::vector challenge; sptr callback = new (nothrow) MockUserAuthCallback(); ASSERT_NE(callback, nullptr); - auto context = factory->CreateIdentifyContext(challenge, static_cast(0), 0, callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_IDENTIFY); + auto context = factory->CreateIdentifyContext(challenge, static_cast(0), 0, contextCallback); ASSERT_NE(context, nullptr); EXPECT_NE(context->GetContextId(), 0U); ASSERT_EQ(context->GetContextType(), CONTEXT_IDENTIFY); @@ -97,7 +100,8 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateIdentify_002, TestSize.Level1) std::vector challenge; // Error: callback is null sptr callback = nullptr; - auto context = factory->CreateIdentifyContext(challenge, static_cast(0), 0, callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_IDENTIFY); + auto context = factory->CreateIdentifyContext(challenge, static_cast(0), 0, contextCallback); ASSERT_EQ(context, nullptr); } @@ -108,8 +112,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateEnrollContext_001, TestSize.Lev std::vector token; sptr callback = new (nothrow) MockIdmCallback(); ASSERT_NE(callback, nullptr); - auto context = - factory->CreateEnrollContext(0, static_cast(0), static_cast(0), token, 0, callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL); + auto context = factory->CreateEnrollContext(0, static_cast(0), static_cast(0), token, + 0, contextCallback); ASSERT_NE(context, nullptr); EXPECT_NE(context->GetContextId(), 0U); ASSERT_EQ(context->GetContextType(), CONTEXT_ENROLL); @@ -122,8 +127,9 @@ HWTEST_F(ContextFactoryTest, ContextFactoryCreateEnrollContext_002, TestSize.Lev std::vector token; // Error: callback is null sptr callback = nullptr; - auto context = - factory->CreateEnrollContext(0, static_cast(0), static_cast(0), token, 0, callback); + auto contextCallback = ContextCallback::NewInstance(callback, TRACE_ADD_CREDENTIAL); + auto context = factory->CreateEnrollContext(0, static_cast(0), static_cast(0), token, + 0, contextCallback); ASSERT_EQ(context, nullptr); } } // namespace UserAuth diff --git a/test/unittest/services/src/enroll_context_test.cpp b/test/unittest/services/src/enroll_context_test.cpp index b969f0536..fc2d617e4 100644 --- a/test/unittest/services/src/enroll_context_test.cpp +++ b/test/unittest/services/src/enroll_context_test.cpp @@ -296,7 +296,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_001, TestSize.Lev ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, testResultCode); }); @@ -319,7 +319,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_002, TestSize.Lev ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -342,7 +342,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_003, TestSize.Lev ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -374,7 +374,7 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_004, TestSize.Lev ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -413,10 +413,10 @@ HWTEST_F(EnrollContextTest, EnrollContextTest_OnScheduleStoped_005, TestSize.Lev ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::SUCCESS); uint64_t credentialId; - bool ret = finalResult->GetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId); + bool ret = finalResult.GetUint64Value(Attributes::ATTR_CREDENTIAL_ID, credentialId); EXPECT_EQ(ret, true); EXPECT_EQ(testCredentialId, credentialId); }); diff --git a/test/unittest/services/src/identify_context_test.cpp b/test/unittest/services/src/identify_context_test.cpp index 8a3aae7b8..46885681c 100644 --- a/test/unittest/services/src/identify_context_test.cpp +++ b/test/unittest/services/src/identify_context_test.cpp @@ -293,7 +293,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_001, TestSize ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, testResultCode); }); @@ -316,7 +316,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_002, TestSize ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -339,7 +339,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_003, TestSize ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -370,7 +370,7 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_004, TestSize ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -408,16 +408,16 @@ HWTEST_F(IdentifyContextTest, IdentifyContextTest_OnScheduleStoped_005, TestSize ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, testResultCode); uint32_t attrResultCode; int32_t userId; vector signature; - bool ret = finalResult->GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode); + bool ret = finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode); EXPECT_EQ(ret, true); - ret = finalResult->GetInt32Value(Attributes::ATTR_USER_ID, userId); + ret = finalResult.GetInt32Value(Attributes::ATTR_USER_ID, userId); EXPECT_EQ(ret, true); - ret = finalResult->GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature); + ret = finalResult.GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature); EXPECT_EQ(ret, true); EXPECT_EQ(resultCode, testResultCode); diff --git a/test/unittest/services/src/simple_auth_context_test.cpp b/test/unittest/services/src/simple_auth_context_test.cpp index 51424ad0f..2b9bc99a3 100644 --- a/test/unittest/services/src/simple_auth_context_test.cpp +++ b/test/unittest/services/src/simple_auth_context_test.cpp @@ -293,7 +293,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_001, Test ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, testResultCode); }); @@ -316,7 +316,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_002, Test ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -339,7 +339,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_003, Test ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -369,7 +369,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_004, Test ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)) .Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::GENERAL_ERROR); }); @@ -408,19 +408,19 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_OnScheduleStoped_005, Test std::shared_ptr contextCallback = MakeShared(); ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)).Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, testResultCode); uint32_t attrResultCode; int32_t freezingTime; int32_t remainTimes; vector signature; - bool ret = finalResult->GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode); + bool ret = finalResult.GetUint32Value(Attributes::ATTR_RESULT_CODE, attrResultCode); EXPECT_EQ(ret, true); - ret = finalResult->GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime); + ret = finalResult.GetInt32Value(Attributes::ATTR_FREEZING_TIME, freezingTime); EXPECT_EQ(ret, true); - ret = finalResult->GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTimes); + ret = finalResult.GetInt32Value(Attributes::ATTR_REMAIN_TIMES, remainTimes); EXPECT_EQ(ret, true); - ret = finalResult->GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature); + ret = finalResult.GetUint8ArrayValue(Attributes::ATTR_SIGNATURE, signature); EXPECT_EQ(ret, true); EXPECT_EQ(resultCode, testResultCode); diff --git a/test/unittest/services/src/user_idm_stub_test.cpp b/test/unittest/services/src/user_idm_stub_test.cpp index dea9ff296..5c76502cf 100644 --- a/test/unittest/services/src/user_idm_stub_test.cpp +++ b/test/unittest/services/src/user_idm_stub_test.cpp @@ -234,10 +234,10 @@ HWTEST_F(UserIdmStubTest, UserIdmStubAddCredentialStub, TestSize.Level1) MockUserIdmService service; const sptr callback = new (std::nothrow) MockIdmCallback(); ASSERT_NE(callback, nullptr); - EXPECT_CALL(service, AddCredential(Eq(std::nullopt), PIN, PIN_SIX, IsEmpty(), _)).Times(1); + EXPECT_CALL(service, AddCredential(Eq(std::nullopt), PIN, PIN_SIX, IsEmpty(), _, true)).Times(1); ON_CALL(service, AddCredential) .WillByDefault([](std::optional userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, const sptr &callback) { + const std::vector &token, const sptr &callback, bool isUpdate) { EXPECT_NE(callback, nullptr); if (callback != nullptr) { Attributes attr; @@ -265,10 +265,10 @@ HWTEST_F(UserIdmStubTest, UserIdmStubAddCredentialByIdStub, TestSize.Level1) MockUserIdmService service; const sptr callback = new (std::nothrow) MockIdmCallback(); ASSERT_NE(callback, nullptr); - EXPECT_CALL(service, AddCredential(Eq(IDM_STUB_TEST_USER_ID), PIN, PIN_SIX, IsEmpty(), _)).Times(1); + EXPECT_CALL(service, AddCredential(Eq(IDM_STUB_TEST_USER_ID), PIN, PIN_SIX, IsEmpty(), _, true)).Times(1); ON_CALL(service, AddCredential) .WillByDefault([](std::optional userId, AuthType authType, PinSubType pinSubType, - const std::vector &token, const sptr &callback) { + const std::vector &token, const sptr &callback, bool isUpdate) { EXPECT_NE(callback, nullptr); if (callback != nullptr) { Attributes attr; From f36717827d929e7b7d06cbd3263e589d9d641dc4 Mon Sep 17 00:00:00 2001 From: youliang_1314 Date: Fri, 1 Jul 2022 17:06:42 +0800 Subject: [PATCH 5/7] fix code check problem Signed-off-by: youliang_1314 Change-Id: Ie34213a501152aae37805e35ce78900bd79d4d88 --- services/context/src/context_callback_impl.cpp | 4 ++-- services/context/src/context_factory.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/services/context/src/context_callback_impl.cpp b/services/context/src/context_callback_impl.cpp index 7633ab3f0..949c88a50 100644 --- a/services/context/src/context_callback_impl.cpp +++ b/services/context/src/context_callback_impl.cpp @@ -87,7 +87,7 @@ void ContextCallbackImpl::OnResult(int32_t resultCode, Attributes &finalResult) ContextCallbackNotifyListener::GetInstance().Process(metaData_); if (stopCallback_ != nullptr) { stopCallback_(); - } + } } void ContextCallbackImpl::SetTraceUserId(int32_t userId) @@ -127,7 +127,7 @@ void ContextCallbackImpl::SetTraceAuthTrustLevel(AuthTrustLevel atl) void ContextCallbackImpl::SetCleaner(Context::ContextStopCallback callback) { - stopCallback_ = callback; + stopCallback_ = callback; } void ContextCallbackNotifyListener::AddNotifier(const Notify ¬ify) diff --git a/services/context/src/context_factory.cpp b/services/context/src/context_factory.cpp index 12cb31938..498110727 100644 --- a/services/context/src/context_factory.cpp +++ b/services/context/src/context_factory.cpp @@ -34,7 +34,7 @@ namespace UserIam { namespace UserAuth { std::shared_ptr ContextFactory::CreateSimpleAuthContext(int32_t userId, const std::vector &challenge, AuthType authType, AuthTrustLevel authTrustLevel, uint64_t callingUid, - const std::shared_ptr &callback) + const std::shared_ptr &callback) { IF_FALSE_LOGE_AND_RETURN_VAL(callback != nullptr, nullptr); uint64_t newContextId = ContextPool::GetNewContextId(); From 0e002948bde7761015f2042bfa80bc94565d6bbf Mon Sep 17 00:00:00 2001 From: youliang_1314 Date: Fri, 1 Jul 2022 17:30:50 +0800 Subject: [PATCH 6/7] fix code Signed-off-by: youliang_1314 Change-Id: I42ecf9be4d23585d88f8ed2858dcd2ee53cf6f84 --- test/unittest/services/src/simple_auth_context_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/unittest/services/src/simple_auth_context_test.cpp b/test/unittest/services/src/simple_auth_context_test.cpp index 7a28cfd9a..2cc69781e 100644 --- a/test/unittest/services/src/simple_auth_context_test.cpp +++ b/test/unittest/services/src/simple_auth_context_test.cpp @@ -464,7 +464,7 @@ HWTEST_F(SimpleAuthContextTest, SimpleAuthContextTest_ContextFree, TestSize.Leve std::shared_ptr contextCallback = MakeShared(); ASSERT_NE(contextCallback, nullptr); EXPECT_CALL(*contextCallback, OnResult(_, _)).Times(Exactly(1)) - .WillOnce([](int32_t resultCode, const std::shared_ptr &finalResult) { + .WillOnce([](int32_t resultCode, Attributes &finalResult) { EXPECT_EQ(resultCode, ResultCode::BUSY); }); From 14d5fabfe6d273b51cdff2b97f7b7cbeb85211ec Mon Sep 17 00:00:00 2001 From: youliang_1314 Date: Fri, 1 Jul 2022 20:04:56 +0800 Subject: [PATCH 7/7] update code Signed-off-by: youliang_1314 Change-Id: I82c630b980b3d40d9141791875618ac8bb3a006f --- dfx/inc/trace.h | 6 ++---- dfx/src/trace.cpp | 8 ++++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/dfx/inc/trace.h b/dfx/inc/trace.h index 91d9c63e6..0b1612e9a 100644 --- a/dfx/inc/trace.h +++ b/dfx/inc/trace.h @@ -22,16 +22,14 @@ namespace OHOS { namespace UserIam { namespace UserAuth { class Trace { -public: - Trace(); - ~Trace(); - private: static Trace trace; static void ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData &metaData); static void ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); static void ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData); static void ProcessDelUserEvent(const ContextCallbackNotifyListener::MetaData &metaData); + Trace(); + ~Trace(); }; } // namespace UserAuth } // namespace UserIam diff --git a/dfx/src/trace.cpp b/dfx/src/trace.cpp index 2a264d27a..0e276f781 100644 --- a/dfx/src/trace.cpp +++ b/dfx/src/trace.cpp @@ -48,8 +48,8 @@ void Trace::ProcessCredChangeEvent(const ContextCallbackNotifyListener::MetaData void Trace::ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData) { - bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() - && metaData.authType != PIN; + bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() && + metaData.authType != PIN; if (!checkRet) { return; } @@ -58,8 +58,8 @@ void Trace::ProcessUserAuthEvent(const ContextCallbackNotifyListener::MetaData & void Trace::ProcessPinAuthEvent(const ContextCallbackNotifyListener::MetaData &metaData) { - bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() - && metaData.authType == PIN; + bool checkRet = metaData.operationType == TRACE_AUTH_USER && metaData.authType.has_value() && + metaData.authType == PIN; if (!checkRet) { return; }