From 4d9d63a5c83f54940ae52b17845254a58964f7a4 Mon Sep 17 00:00:00 2001 From: louzhihao Date: Thu, 14 Aug 2025 21:44:47 +0800 Subject: [PATCH] permission Signed-off-by: louzhihao Change-Id: Iee2740b4b616c7000f8f819af4baebf3fc4fb15f --- .../include/dataobs_mgr_client.h | 25 ++ .../include/dataobs_mgr_errors.h | 3 + .../include/dataobs_mgr_interface.h | 35 +++ services/dataobsmgr/BUILD.gn | 12 + .../include/dataobs_mgr_inner_common.h | 19 ++ .../include/dataobs_mgr_inner_ext.h | 20 +- .../dataobsmgr/include/dataobs_mgr_proxy.h | 22 +- .../dataobsmgr/include/dataobs_mgr_service.h | 13 + .../dataobsmgr/include/dataobs_mgr_stub.h | 3 + .../dataobsmgr/src/dataobs_mgr_client.cpp | 62 ++++- services/dataobsmgr/src/dataobs_mgr_inner.cpp | 21 +- .../dataobsmgr/src/dataobs_mgr_inner_ext.cpp | 37 ++- services/dataobsmgr/src/dataobs_mgr_proxy.cpp | 98 ++++++- .../dataobsmgr/src/dataobs_mgr_service.cpp | 163 +++++++++--- services/dataobsmgr/src/dataobs_mgr_stub.cpp | 54 +++- .../mock_dataobs_mgr_service.h | 5 + .../dataobs_mgr_inner_ext_test.cpp | 106 ++++---- .../mock_data_obs_mgr_stub.h | 4 + .../dataobs_mgr_service_test/BUILD.gn | 1 + .../dataobs_mgr_service_test.cpp | 247 ++++++++++-------- .../mock_data_obs_mgr_stub.h | 4 + 21 files changed, 739 insertions(+), 215 deletions(-) diff --git a/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_client.h b/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_client.h index 109bfb6a569..4c5a95a6338 100644 --- a/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_client.h +++ b/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_client.h @@ -50,6 +50,17 @@ public: int32_t userId = IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()); + /** + * Registers an observer to DataObsMgr specified by the given Uri. + * + * @param uri, Indicates the path of the data to operate. + * @param dataObserver, Indicates the IDataAbilityObserver object. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode RegisterObserverFromExtension(const Uri &uri, sptr dataObserver, + int32_t userId = IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()); + /** * Deregisters an observer used for DataObsMgr specified by the given Uri. * @@ -71,6 +82,18 @@ public: ErrCode NotifyChange(const Uri &uri, int32_t userId = IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()); + /** + * Notifies the registered observers of a change to the data resource specified by Uri. + * + * @param uri, Indicates the path of the data to operate. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode NotifyChangeFromExtension(const Uri &uri, int32_t userId = IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, + DataObsOption opt = DataObsOption()); + + ErrCode CheckTrusts(uint32_t consumerToken, uint32_t providerToken); + /** * Registers an observer to DataObsMgr specified by the given Uri. * @@ -158,6 +181,8 @@ private: struct ObserverInfo { Uri uri; int32_t userId; + bool isExtension = false; + uint32_t firstCallerTokenID; ObserverInfo(Uri uri, int32_t userId) : uri(uri), userId(userId) {}; }; ConcurrentMap, std::list> observers_; diff --git a/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_errors.h b/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_errors.h index 13354cb0ac9..8a055c56653 100644 --- a/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_errors.h +++ b/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_errors.h @@ -53,6 +53,9 @@ enum Status : int32_t { GET_TOKENINFO_ERR, DATAOBS_INVALID_USERID, DATAOBS_NOT_SYSTEM_APP, + BMS_NOT_READY, + COMMON_ERROR, + URI_NOT_EXIST }; } // namespace AAFwk } // namespace OHOS diff --git a/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_interface.h b/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_interface.h index d92de5944a6..e9fbcad2d96 100644 --- a/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_interface.h +++ b/interfaces/inner_api/dataobs_manager/include/dataobs_mgr_interface.h @@ -33,6 +33,7 @@ constexpr const char* DATAOBS_MANAGER_SERVICE_NAME = "DataObsMgrService"; struct DataObsOption { private: bool isSystem = false; + uint32_t firstCallerTokenID = 0; public: DataObsOption() {} DataObsOption(bool isSystem):isSystem(isSystem) {} @@ -40,6 +41,14 @@ public: { return isSystem; } + uint32_t FirstCallerTokenID() + { + return firstCallerTokenID; + } + void SetFirstCallerTokenID(uint32_t token) + { + firstCallerTokenID = token; + } }; /** @@ -60,6 +69,9 @@ public: UNREGISTER_OBSERVER_ALL_EXT, NOTIFY_CHANGE_EXT, NOTIFY_PROCESS, + REGISTER_OBSERVER_FROM_EXTENSION, + NOTIFY_CHANGE_FROM_EXTENSION, + CHECK_TRUSTS, TRANS_BUTT, }; @@ -77,6 +89,17 @@ public: int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) = 0; + /** + * Registers an observer to DataObsMgr specified by the given Uri. + * + * @param uri, Indicates the path of the data to operate. + * @param dataObserver, Indicates the IDataAbilityObserver object. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int RegisterObserverFromExtension(const Uri &uri, sptr dataObserver, + int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) = 0; + /** * Deregisters an observer used for DataObsMgr specified by the given Uri. * @@ -99,6 +122,18 @@ public: virtual int NotifyChange(const Uri &uri, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) = 0; + /** + * Notifies the registered observers of a change to the data resource specified by Uri. + * + * @param uri, Indicates the path of the data to operate. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int NotifyChangeFromExtension(const Uri &uri, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, + DataObsOption opt = DataObsOption()) = 0; + + virtual ErrCode CheckTrusts(uint32_t consumerToken, uint32_t providerToken) = 0; + /** * Registers an observer to DataObsMgr specified by the given Uri. * diff --git a/services/dataobsmgr/BUILD.gn b/services/dataobsmgr/BUILD.gn index db27dae56ae..868550c74e9 100644 --- a/services/dataobsmgr/BUILD.gn +++ b/services/dataobsmgr/BUILD.gn @@ -52,14 +52,20 @@ ohos_shared_library("dataobsms") { "ability_base:zuri", "access_token:libaccesstoken_sdk", "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", + "data_share:datashare_permission", "ffrt:libffrt", "hilog:libhilog", "image_framework:image_native", "ipc:ipc_core", "json:nlohmann_json_static", + "resource_management:global_resmgr", "safwk:system_ability_fwk", "samgr:samgr_proxy", + "os_account:os_account_innerkits" ] defines = [] @@ -95,14 +101,20 @@ ohos_static_library("dataobsms_static") { "ability_base:zuri", "access_token:libaccesstoken_sdk", "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", "c_utils:utils", + "cJSON:cjson", + "data_share:datashare_permission", "ffrt:libffrt", "hilog:libhilog", "image_framework:image_native", "ipc:ipc_core", "json:nlohmann_json_static", + "resource_management:global_resmgr", "safwk:system_ability_fwk", "samgr:samgr_proxy", + "os_account:os_account_innerkits" ] defines = [] diff --git a/services/dataobsmgr/include/dataobs_mgr_inner_common.h b/services/dataobsmgr/include/dataobs_mgr_inner_common.h index b7ecb6569ce..8a53106ed7d 100644 --- a/services/dataobsmgr/include/dataobs_mgr_inner_common.h +++ b/services/dataobsmgr/include/dataobs_mgr_inner_common.h @@ -17,14 +17,33 @@ #define OHOS_ABILITY_RUNTIME_DATAOBS_MGR_INNER_COMMON_H #include "data_ability_observer_interface.h" +#include namespace OHOS { namespace AAFwk { +struct ObserverInfo { + ObserverInfo() {} + ObserverInfo(uint32_t tokenId, uint64_t fullTokenId, uint32_t firstCallerTokenId, int32_t userId, bool isExtension) + : tokenId(tokenId), fullTokenId(fullTokenId), firstCallerTokenId(firstCallerTokenId), userId(userId), + isExtension(isExtension) {} + uint32_t tokenId = 0; + uint64_t fullTokenId = 0; + uint32_t firstCallerTokenId = 0; + int32_t userId = -1; + int32_t callingUserId = -1; + bool isExtension = false; + std::string permission; + std::string errMsg; +}; + struct ObserverNode { sptr observer_ = nullptr; int32_t userId_ = -1; uint32_t tokenId_ = 0; + uint32_t firstCallerTokenID_ = 0; + bool isExtension_ = false; + std::string permission_; ObserverNode(sptr observer, int32_t userId, uint32_t tokenId):observer_(observer), userId_(userId), tokenId_(tokenId) {} diff --git a/services/dataobsmgr/include/dataobs_mgr_inner_ext.h b/services/dataobsmgr/include/dataobs_mgr_inner_ext.h index fd065cd22ee..b95f4932641 100644 --- a/services/dataobsmgr/include/dataobs_mgr_inner_ext.h +++ b/services/dataobsmgr/include/dataobs_mgr_inner_ext.h @@ -29,6 +29,7 @@ #include "dataobs_mgr_inner_common.h" #include "iremote_object.h" #include "refbase.h" +#include "uri.h" namespace OHOS { namespace AAFwk { @@ -38,8 +39,8 @@ public: DataObsMgrInnerExt(); virtual ~DataObsMgrInnerExt(); - Status HandleRegisterObserver(Uri &uri, sptr dataObserver, int32_t userId, - uint32_t tokenId, bool isDescendants = false); + Status HandleRegisterObserver(Uri &uri, sptr dataObserver, ObserverInfo &info, + bool isDescendants = false); Status HandleUnregisterObserver(Uri &uri, sptr dataObserver); Status HandleUnregisterObserver(sptr dataObserver); Status HandleNotifyChange(const ChangeInfo &changeInfo, int32_t userId); @@ -63,9 +64,22 @@ private: uint32_t tokenId = 0; std::shared_ptr deathRecipientRef; bool isDescendants; + std::string permission; }; - using ObsMap = std::map, std::list>; + struct ObsNotifyInfo { + ObsNotifyInfo() + { + tokenId = 0; + permission = ""; + uriList = std::list(); + } + uint32_t tokenId; + std::string permission; + std::list uriList; + }; + + using ObsMap = std::map, ObsNotifyInfo>; using EntryList = std::list; class Node { diff --git a/services/dataobsmgr/include/dataobs_mgr_proxy.h b/services/dataobsmgr/include/dataobs_mgr_proxy.h index f7f3cee51f5..317d6d93024 100644 --- a/services/dataobsmgr/include/dataobs_mgr_proxy.h +++ b/services/dataobsmgr/include/dataobs_mgr_proxy.h @@ -44,7 +44,10 @@ public: */ virtual int RegisterObserver(const Uri &uri, sptr dataObserver, - int32_t userId = -1, DataObsOption opt = DataObsOption()) override; + int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) override; + + virtual int RegisterObserverFromExtension(const Uri &uri, sptr dataObserver, + int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) override; /** * Deregisters an observer used for DataObsMgr specified by the given Uri. @@ -55,7 +58,17 @@ public: * @return Returns ERR_OK on success, others on failure. */ virtual int UnregisterObserver(const Uri &uri, sptr dataObserver, - int32_t userId = -1, DataObsOption opt = DataObsOption()) override; + int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) override; + + /** + * Notifies the registered observers of a change to the data resource specified by Uri. + * + * @param uri, Indicates the path of the data to operate. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int NotifyChange(const Uri &uri, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, + DataObsOption opt = DataObsOption()) override; /** * Notifies the registered observers of a change to the data resource specified by Uri. @@ -64,7 +77,10 @@ public: * * @return Returns ERR_OK on success, others on failure. */ - virtual int NotifyChange(const Uri &uri, int32_t userId = -1, DataObsOption opt = DataObsOption()) override; + virtual int NotifyChangeFromExtension(const Uri &uri, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, + DataObsOption opt = DataObsOption()) override; + + virtual int CheckTrusts(uint32_t consumerToken, uint32_t providerToken) override; /** * Registers an observer to DataObsMgr specified by the given Uri. diff --git a/services/dataobsmgr/include/dataobs_mgr_service.h b/services/dataobsmgr/include/dataobs_mgr_service.h index 8634d002ff3..951882d60b2 100644 --- a/services/dataobsmgr/include/dataobs_mgr_service.h +++ b/services/dataobsmgr/include/dataobs_mgr_service.h @@ -23,6 +23,7 @@ #include "cpp/mutex.h" #include "dataobs_mgr_inner.h" +#include "dataobs_mgr_inner_common.h" #include "dataobs_mgr_inner_ext.h" #include "dataobs_mgr_inner_pref.h" #include "dataobs_mgr_stub.h" @@ -54,11 +55,17 @@ public: virtual int RegisterObserver(const Uri &uri, sptr dataObserver, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) override; + virtual int RegisterObserverFromExtension(const Uri &uri, + sptr dataObserver, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, + DataObsOption opt = DataObsOption()) override; virtual int UnregisterObserver(const Uri &uri, sptr dataObserver, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) override; virtual int NotifyChange(const Uri &uri, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, DataObsOption opt = DataObsOption()) override; + virtual int NotifyChangeFromExtension(const Uri &uri, int32_t userId = DATAOBS_DEFAULT_CURRENT_USER, + DataObsOption opt = DataObsOption()) override; + virtual int CheckTrusts(uint32_t consumerToken, uint32_t providerToken) override; virtual Status RegisterObserverExt(const Uri &uri, sptr dataObserver, bool isDescendants, DataObsOption opt = DataObsOption()) override; virtual Status UnregisterObserverExt(const Uri &uri, sptr dataObserver, @@ -90,6 +97,12 @@ private: static bool IsCallingPermissionValid(DataObsOption &opt); static int32_t GetDataMgrServiceUid(); static bool IsDataMgrService(uint32_t tokenId, int32_t uid); + int32_t RegisterObserverInner(const Uri &uri, sptr dataObserver, int32_t userId, + DataObsOption opt, bool isExtension); + int32_t VerifyDataSharePermission(Uri &uri, bool isRead, ObserverInfo &info); + int32_t VerifyDataSharePermissionInner(Uri &uri, bool isRead, ObserverInfo &info); + int32_t NotifyChangeInner(Uri &uri, int32_t userId, + DataObsOption opt, bool isExtension); private: static constexpr std::uint32_t TASK_COUNT_MAX = 50; ffrt::mutex taskCountMutex_; diff --git a/services/dataobsmgr/include/dataobs_mgr_stub.h b/services/dataobsmgr/include/dataobs_mgr_stub.h index 53331f1c7bb..a94fe848f53 100644 --- a/services/dataobsmgr/include/dataobs_mgr_stub.h +++ b/services/dataobsmgr/include/dataobs_mgr_stub.h @@ -39,8 +39,11 @@ public: private: int32_t RegisterObserverInner(MessageParcel &data, MessageParcel &reply); + int32_t RegisterObserverFromExtensionInner(MessageParcel &data, MessageParcel &reply); int32_t UnregisterObserverInner(MessageParcel &data, MessageParcel &reply); int32_t NotifyChangeInner(MessageParcel &data, MessageParcel &reply); + int32_t NotifyChangeFromExtensionInner(MessageParcel &data, MessageParcel &reply); + int32_t VerifyWhiteListInner(MessageParcel &data, MessageParcel &reply); int32_t RegisterObserverExtInner(MessageParcel &data, MessageParcel &reply); int32_t UnregisterObserverExtInner(MessageParcel &data, MessageParcel &reply); int32_t UnregisterObserverExtALLInner(MessageParcel &data, MessageParcel &reply); diff --git a/services/dataobsmgr/src/dataobs_mgr_client.cpp b/services/dataobsmgr/src/dataobs_mgr_client.cpp index c35dd66367c..b58a4deb39d 100644 --- a/services/dataobsmgr/src/dataobs_mgr_client.cpp +++ b/services/dataobsmgr/src/dataobs_mgr_client.cpp @@ -17,6 +17,7 @@ #include "dataobs_mgr_client.h" #include "common_utils.h" +#include "dataobs_mgr_interface.h" #include "datashare_log.h" #include "hilog_tag_wrapper.h" #include "if_system_ability_manager.h" @@ -119,6 +120,29 @@ ErrCode DataObsMgrClient::RegisterObserver(const Uri &uri, sptr dataObserver, + int userId, DataObsOption opt) +{ + auto [errCode, dataObsManger] = GetObsMgr(); + if (errCode != SUCCESS) { + LOG_ERROR("Failed to get ObsMgr, errCode: %{public}d.", errCode); + return DATAOBS_SERVICE_NOT_CONNECTED; + } + auto status = dataObsManger->RegisterObserverFromExtension(uri, dataObserver, userId, opt); + if (status != NO_ERROR) { + return status; + } + uint32_t firstCallerTokenID = opt.FirstCallerTokenID(); + observers_.Compute(dataObserver, [&uri, userId, firstCallerTokenID](const auto &key, auto &value) { + ObserverInfo info(uri, userId); + info.isExtension = true; + info.firstCallerTokenID = firstCallerTokenID; + value.emplace_back(uri, userId); + return true; + }); + return status; +} + /** * Deregisters an observer used for DataObsMgr specified by the given Uri. * @@ -163,6 +187,31 @@ ErrCode DataObsMgrClient::NotifyChange(const Uri &uri, int userId, DataObsOption return dataObsManger->NotifyChange(uri, userId, opt); } +/** + * Notifies the registered observers of a change to the data resource specified by Uri. + * + * @param uri, Indicates the path of the data to operate. + * + * @return Returns ERR_OK on success, others on failure. + */ +ErrCode DataObsMgrClient::NotifyChangeFromExtension(const Uri &uri, int userId, DataObsOption opt) +{ + auto [errCode, dataObsManger] = GetObsMgr(); + if (errCode != SUCCESS) { + return DATAOBS_SERVICE_NOT_CONNECTED; + } + return dataObsManger->NotifyChangeFromExtension(uri, userId, opt); +} + +ErrCode DataObsMgrClient::CheckTrusts(uint32_t consumerToken, uint32_t providerToken) +{ + auto [errCode, dataObsManger] = GetObsMgr(); + if (errCode != SUCCESS) { + return DATAOBS_SERVICE_NOT_CONNECTED; + } + return dataObsManger->CheckTrusts(consumerToken, providerToken); +} + /** * Connect dataobs manager service. * @@ -304,10 +353,17 @@ void DataObsMgrClient::ReRegister() observers_.Clear(); observers.ForEach([this](const auto &key, const auto &value) { for (const auto &val : value) { - auto ret = RegisterObserver(val.uri, key, val.userId); + int32_t ret; + if (val.isExtension) { + DataObsOption opt; + opt.SetFirstCallerTokenID(val.firstCallerTokenID); + ret = RegisterObserverFromExtension(val.uri, key, val.userId, opt); + } else { + ret = RegisterObserver(val.uri, key, val.userId); + } if (ret != SUCCESS) { - LOG_ERROR("RegisterObserver failed, uri:%{public}s, ret:%{public}d", - CommonUtils::Anonymous(val.uri.ToString()).c_str(), ret); + LOG_ERROR("RegisterObserver failed, uri:%{public}s, ret:%{public}d, isExtension %{public}d", + CommonUtils::Anonymous(val.uri.ToString()).c_str(), ret, val.isExtension); } } return false; diff --git a/services/dataobsmgr/src/dataobs_mgr_inner.cpp b/services/dataobsmgr/src/dataobs_mgr_inner.cpp index 10787ade8a4..b49b4b2cb77 100644 --- a/services/dataobsmgr/src/dataobs_mgr_inner.cpp +++ b/services/dataobsmgr/src/dataobs_mgr_inner.cpp @@ -15,9 +15,12 @@ #include "dataobs_mgr_inner.h" #include "data_ability_observer_stub.h" +#include "data_share_permission.h" #include "dataobs_mgr_errors.h" +#include "datashare_errno.h" #include "hilog_tag_wrapper.h" #include "common_utils.h" +#include namespace OHOS { namespace AAFwk { @@ -99,13 +102,14 @@ int DataObsMgrInner::HandleUnregisterObserver(const Uri &uri, struct ObserverNod int DataObsMgrInner::HandleNotifyChange(const Uri &uri, int32_t userId) { + std::string uriStr = uri.ToString(); std::list obsList; std::lock_guard lock(innerMutex_); { - auto obsPair = observers_.find(uri.ToString()); + auto obsPair = observers_.find(uriStr); if (obsPair == observers_.end()) { TAG_LOGD(AAFwkTag::DBOBSMGR, "uri no obs:%{public}s", - CommonUtils::Anonymous(uri.ToString()).c_str()); + CommonUtils::Anonymous(uriStr).c_str()); return NO_OBS_FOR_URI; } obsList = obsPair->second; @@ -117,9 +121,20 @@ int DataObsMgrInner::HandleNotifyChange(const Uri &uri, int32_t userId) } if (obs.userId_ != 0 && userId != 0 && obs.userId_ != userId) { TAG_LOGW(AAFwkTag::DBOBSMGR, "Not allow across user notify, %{public}d to %{public}d, %{public}s", - userId, obs.userId_, CommonUtils::Anonymous(uri.ToString()).c_str()); + userId, obs.userId_, CommonUtils::Anonymous(uriStr).c_str()); continue; } + uint32_t token = obs.isExtension_ ? obs.firstCallerTokenID_ : obs.tokenId_; + std::string permission = obs.permission_; + if (!permission.empty() && !DataShare::DataSharePermission::VerifyPermission(token, + permission)) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "HandleNotifyChange permission denied, token %{public}d permission " + "%{public}s uri %{public}s", token, permission.c_str(), CommonUtils::Anonymous(uriStr).c_str()); + // just hisysevent now + std::string msg = __FUNCTION__; + DataShare::DataSharePermission::ReportExtensionFault(DataShare::E_DATASHARE_PERMISSION_DENIED, token, + uriStr, msg); + } obs.observer_->OnChange(); } diff --git a/services/dataobsmgr/src/dataobs_mgr_inner_ext.cpp b/services/dataobsmgr/src/dataobs_mgr_inner_ext.cpp index b6d5049fe20..25f2016cb70 100644 --- a/services/dataobsmgr/src/dataobs_mgr_inner_ext.cpp +++ b/services/dataobsmgr/src/dataobs_mgr_inner_ext.cpp @@ -15,6 +15,8 @@ #include "dataobs_mgr_inner_ext.h" #include "data_ability_observer_stub.h" +#include "data_share_permission.h" +#include "datashare_errno.h" #include "dataobs_mgr_errors.h" #include "hilog_tag_wrapper.h" #include "common_utils.h" @@ -27,7 +29,7 @@ DataObsMgrInnerExt::DataObsMgrInnerExt() : root_(std::make_shared("root")) DataObsMgrInnerExt::~DataObsMgrInnerExt() {} Status DataObsMgrInnerExt::HandleRegisterObserver(Uri &uri, sptr dataObserver, - int32_t userId, uint32_t tokenId, bool isDescendants) + ObserverInfo &info, bool isDescendants) { if (dataObserver->AsObject() == nullptr) { return DATA_OBSERVER_IS_NULL; @@ -40,8 +42,8 @@ Status DataObsMgrInnerExt::HandleRegisterObserver(Uri &uri, sptr path = { uri.GetScheme(), uri.GetAuthority() }; uri.GetPathSegments(path); - if (root_ != nullptr && !root_->AddObserver(path, 0, Entry(dataObserver, userId, tokenId, - deathRecipientRef, isDescendants))) { + Entry entry = Entry(dataObserver, info.userId, info.tokenId, deathRecipientRef, isDescendants); + if (root_ != nullptr && !root_->AddObserver(path, 0, entry)) { TAG_LOGE(AAFwkTag::DBOBSMGR, "subscribers:%{public}s num maxed", CommonUtils::Anonymous(uri.ToString()).c_str()); @@ -104,10 +106,23 @@ Status DataObsMgrInnerExt::HandleNotifyChange(const ChangeInfo &changeInfo, int3 return NO_OBS_FOR_URI; } for (const auto &[obs, value] : changeRes) { - if (obs != nullptr && !value.empty()) { - obs->OnChangeExt( - { changeInfo.changeType_, move(value), changeInfo.data_, changeInfo.size_, changeInfo.valueBuckets_ }); + if (obs == nullptr || value.uriList.empty()) { + continue; } + std::string permission = value.permission; + if (!permission.empty() && + !DataShare::DataSharePermission::VerifyPermission(value.tokenId, permission)) { + std::string uriStr = value.uriList.front().ToString(); + TAG_LOGW(AAFwkTag::DBOBSMGR, "permission deny, uri:%{public}s, token %{public}d permission %{public}s", + CommonUtils::Anonymous(uriStr).c_str(), value.tokenId, permission.c_str()); + // just hisysevent now + std::string msg = __FUNCTION__; + DataShare::DataSharePermission::ReportExtensionFault(DataShare::E_DATASHARE_PERMISSION_DENIED, + value.tokenId, uriStr, msg); + } + obs->OnChangeExt( + { changeInfo.changeType_, move(value.uriList), + changeInfo.data_, changeInfo.size_, changeInfo.valueBuckets_ }); } return SUCCESS; @@ -181,7 +196,10 @@ void DataObsMgrInnerExt::Node::GetObs(const std::vector &path, uint "%{public}d", CommonUtils::Anonymous(uri.ToString()).c_str(), userId, entry.userId); continue; } - obsRes.try_emplace(entry.observer, std::list()).first->second.push_back(uri); + ObsNotifyInfo ¬ifyInfo = obsRes.try_emplace(entry.observer, ObsNotifyInfo()).first->second; + notifyInfo.uriList.push_back(uri); + notifyInfo.tokenId = entry.tokenId; + notifyInfo.permission = entry.permission; } return; } @@ -193,7 +211,10 @@ void DataObsMgrInnerExt::Node::GetObs(const std::vector &path, uint "%{public}d", CommonUtils::Anonymous(uri.ToString()).c_str(), userId, entry.userId); continue; } - obsRes.try_emplace(entry.observer, std::list()).first->second.push_back(uri); + ObsNotifyInfo ¬ifyInfo = obsRes.try_emplace(entry.observer, ObsNotifyInfo()).first->second; + notifyInfo.uriList.push_back(uri); + notifyInfo.tokenId = entry.tokenId; + notifyInfo.permission = entry.permission; } } diff --git a/services/dataobsmgr/src/dataobs_mgr_proxy.cpp b/services/dataobsmgr/src/dataobs_mgr_proxy.cpp index d9e3d2afb0d..368bba052be 100644 --- a/services/dataobsmgr/src/dataobs_mgr_proxy.cpp +++ b/services/dataobsmgr/src/dataobs_mgr_proxy.cpp @@ -57,6 +57,10 @@ bool DataObsManagerProxy::WriteObsOpt(MessageParcel &data, DataObsOption opt) TAG_LOGE(AAFwkTag::DBOBSMGR, "write opt error"); return false; } + if (!data.WriteUint32(opt.FirstCallerTokenID())) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "write opt error"); + return false; + } return true; } @@ -80,7 +84,7 @@ int32_t DataObsManagerProxy::RegisterObserver(const Uri &uri, if (!WriteObsOpt(data, opt)) { return INVALID_PARAM; } - + auto error = SendTransactCmd(IDataObsMgr::REGISTER_OBSERVER, data, reply, option); if (error != NO_ERROR) { TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error, @@ -92,6 +96,39 @@ int32_t DataObsManagerProxy::RegisterObserver(const Uri &uri, return reply.ReadInt32(res) ? res : IPC_ERROR; } +int32_t DataObsManagerProxy::RegisterObserverFromExtension(const Uri &uri, + sptr dataObserver, int32_t userId, + DataObsOption opt) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return IPC_PARCEL_ERROR; + } + + if (!WriteParam(data, uri, dataObserver)) { + return INVALID_PARAM; + } + if (!data.WriteInt32(userId)) { + return INVALID_PARAM; + } + if (!WriteObsOpt(data, opt)) { + return INVALID_PARAM; + } + + auto error = SendTransactCmd(IDataObsMgr::REGISTER_OBSERVER_FROM_EXTENSION, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error, + CommonUtils::Anonymous(uri.ToString()).c_str()); + return error; + } + + int32_t res = IPC_ERROR; + return reply.ReadInt32(res) ? res : IPC_ERROR; +} + int32_t DataObsManagerProxy::UnregisterObserver(const Uri &uri, sptr dataObserver, int32_t userId, DataObsOption opt) { @@ -154,6 +191,65 @@ int32_t DataObsManagerProxy::NotifyChange(const Uri &uri, int32_t userId, DataOb return reply.ReadInt32(res) ? res : IPC_ERROR; } +int32_t DataObsManagerProxy::NotifyChangeFromExtension(const Uri &uri, int32_t userId, DataObsOption opt) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return IPC_PARCEL_ERROR; + } + if (!data.WriteString(uri.ToString())) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "write uri error, uri:%{public}s", + CommonUtils::Anonymous(uri.ToString()).c_str()); + return INVALID_PARAM; + } + if (!data.WriteInt32(userId)) { + return INVALID_PARAM; + } + if (!WriteObsOpt(data, opt)) { + return INVALID_PARAM; + } + auto error = SendTransactCmd(IDataObsMgr::NOTIFY_CHANGE_FROM_EXTENSION, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, uri:%{public}s", error, + CommonUtils::Anonymous(uri.ToString()).c_str()); + return IPC_ERROR; + } + + int32_t res = IPC_ERROR; + return reply.ReadInt32(res) ? res : IPC_ERROR; +} + +ErrCode DataObsManagerProxy::CheckTrusts(uint32_t consumerToken, uint32_t providerToken) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return IPC_PARCEL_ERROR; + } + + if (!data.WriteUint32(consumerToken)) { + return INVALID_PARAM; + } + if (!data.WriteUint32(providerToken)) { + return INVALID_PARAM; + } + + auto error = SendTransactCmd(IDataObsMgr::CHECK_TRUSTS, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "sendRequest error:%{public}d, consumer:%{public}d, provider:%{public}d", error, + consumerToken, providerToken); + return IPC_ERROR; + } + + int32_t res = IPC_ERROR; + return reply.ReadInt32(res) ? res : IPC_ERROR; +} + Status DataObsManagerProxy::RegisterObserverExt(const Uri &uri, sptr dataObserver, bool isDescendants, DataObsOption opt) { diff --git a/services/dataobsmgr/src/dataobs_mgr_service.cpp b/services/dataobsmgr/src/dataobs_mgr_service.cpp index 97eb17b0b16..fbfa44a2ae3 100644 --- a/services/dataobsmgr/src/dataobs_mgr_service.cpp +++ b/services/dataobsmgr/src/dataobs_mgr_service.cpp @@ -12,7 +12,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #include "dataobs_mgr_service.h" #include @@ -25,12 +24,16 @@ #include "ability_manager_proxy.h" #include "accesstoken_kit.h" #include "dataobs_mgr_errors.h" +#include "data_share_permission.h" +#include "datashare_log.h" +#include "dataobs_mgr_inner_common.h" +#include "datashare_errno.h" #include "hilog_tag_wrapper.h" #include "if_system_ability_manager.h" #include "in_process_call_wrapper.h" #include "ipc_skeleton.h" #include "iservice_registry.h" -#include "system_ability.h" +#include "os_account_manager.h" #include "system_ability_definition.h" #include "tokenid_kit.h" #include "common_utils.h" @@ -43,9 +46,11 @@ namespace OHOS { namespace AAFwk { +using namespace DataShare; static constexpr const char *DIALOG_APP = "com.ohos.pasteboarddialog"; static constexpr const char *PROGRESS_ABILITY = "PasteboardProgressAbility"; static constexpr const char *PROMPT_TEXT = "PromptText_PasteBoard_Local"; +static constexpr const char *NO_PERMISSION = "noPermission"; const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(DelayedSingleton::GetInstance().get()); @@ -225,8 +230,78 @@ bool DataObsMgrService::IsCallingPermissionValid(DataObsOption &opt, int32_t use return true; } -int DataObsMgrService::RegisterObserver(const Uri &uri, sptr dataObserver, +std::string FormatUri(const std::string &uri) +{ + auto pos = uri.find_last_of('?'); + if (pos == std::string::npos) { + return uri; + } + + return uri.substr(0, pos); +} + +int32_t DataObsMgrService::RegisterObserver(const Uri &uri, sptr dataObserver, int32_t userId, DataObsOption opt) +{ + return RegisterObserverInner(uri, dataObserver, userId, opt, false); +} + +int32_t DataObsMgrService::RegisterObserverFromExtension(const Uri &uri, sptr dataObserver, + int32_t userId, DataObsOption opt) +{ + return RegisterObserverInner(uri, dataObserver, userId, opt, true); +} + +// just hisysevent now +int32_t DataObsMgrService::VerifyDataSharePermission(Uri &uri, bool isRead, ObserverInfo &info) +{ + std::string uriStr = uri.ToString(); + uint32_t tokenId = info.tokenId; + uint64_t fullTokenId = info.fullTokenId; + int ret; + bool isExtension = info.isExtension; + if (isExtension) { + ret = DataShare::DataSharePermission::IsExtensionValid(tokenId, fullTokenId, info.callingUserId); + if (ret != DataShare::E_OK) { + info.errMsg.append(std::to_string(info.isExtension) + "_IsExtensionValid"); + TAG_LOGE(AAFwkTag::DBOBSMGR, "IsExtensionValid failed, uri:%{public}s, ret %{public}d," + "fullToken %{public}" PRId64 " msg %{public}s", uriStr.c_str(), ret, fullTokenId, info.errMsg.c_str()); + DataShare::DataSharePermission::ReportExtensionFault(ret, tokenId, uriStr, info.errMsg); + return ret; + } + } + return VerifyDataSharePermissionInner(uri, isRead, info); +} + +int32_t DataObsMgrService::VerifyDataSharePermissionInner(Uri &uri, bool isRead, ObserverInfo &info) +{ + std::string uriStr = uri.ToString(); + uint32_t tokenId = info.tokenId; + uint64_t fullTokenId = info.fullTokenId; + int ret; + bool isExtension = info.isExtension; + std::tie(ret, info.permission) = DataShare::DataSharePermission::GetUriPermission(uri, + info.userId, isRead, isExtension); + if (ret != DataShare::E_OK) { + info.errMsg.append(std::to_string(info.isExtension) + "_GetUriPermission"); + TAG_LOGE(AAFwkTag::DBOBSMGR, "GetUriPermission failed, uri:%{public}s, isExtension %{public}d," + "token %{public}d", uriStr.c_str(), isExtension, tokenId); + DataShare::DataSharePermission::ReportExtensionFault(ret, tokenId, uriStr, info.errMsg); + return ret; + } + uint32_t verifyToken = isExtension ? info.firstCallerTokenId : tokenId; + if (!DataShare::DataSharePermission::VerifyPermission(uri, verifyToken, info.permission, isExtension)) { + info.errMsg.append(std::to_string(info.isExtension) + "_VerifyPermission"); + TAG_LOGE(AAFwkTag::DBOBSMGR, "VerifyPermission failed, uri:%{public}s, isExtension %{public}d," + "token %{public}d", uriStr.c_str(), isExtension, tokenId); + DataShare::DataSharePermission::ReportExtensionFault(ret, tokenId, uriStr, info.errMsg); + return DataShare::E_DATASHARE_PERMISSION_DENIED; + } + return 0; +} + +int32_t DataObsMgrService::RegisterObserverInner(const Uri &uri, sptr dataObserver, + int32_t userId, DataObsOption opt, bool isExtension) { if (dataObserver == nullptr) { TAG_LOGE(AAFwkTag::DBOBSMGR, "null dataObserver, uri:%{public}s", @@ -241,11 +316,11 @@ int DataObsMgrService::RegisterObserver(const Uri &uri, sptr(uri).GetScheme() == SHARE_PREFERENCES) { status = dataObsMgrInnerPref_->HandleRegisterObserver(uri, observerNode); @@ -316,20 +397,41 @@ int DataObsMgrService::UnregisterObserver(const Uri &uri, sptr lck(taskCountMutex_); if (taskCount_ >= TASK_COUNT_MAX) { @@ -351,7 +458,6 @@ int DataObsMgrService::NotifyChange(const Uri &uri, int32_t userId, DataObsOptio } ++taskCount_; } - ChangeInfo changeInfo = { ChangeInfo::ChangeType::OTHER, { uri } }; handler_->SubmitTask([this, uri, changeInfo, userId]() { if (const_cast(uri).GetScheme() == SHARE_PREFERENCES) { @@ -363,7 +469,6 @@ int DataObsMgrService::NotifyChange(const Uri &uri, int32_t userId, DataObsOptio std::lock_guard lck(taskCountMutex_); --taskCount_; }); - return NO_ERROR; } @@ -392,9 +497,13 @@ Status DataObsMgrService::RegisterObserverExt(const Uri &uri, sptrHandleRegisterObserver(innerUri, dataObserver, userId, tokenId, isDescendants); + return dataObsMgrInnerExt_->HandleRegisterObserver(innerUri, dataObserver, info, isDescendants); } Status DataObsMgrService::UnregisterObserverExt(const Uri &uri, sptr dataObserver, @@ -463,48 +572,42 @@ Status DataObsMgrService::NotifyChangeExt(const ChangeInfo &changeInfo, DataObsO TAG_LOGE(AAFwkTag::DBOBSMGR, "null handler"); return DATAOBS_SERVICE_HANDLER_IS_NULL; } - if (dataObsMgrInner_ == nullptr || dataObsMgrInnerExt_ == nullptr) { - TAG_LOGE(AAFwkTag::DBOBSMGR, "dataObsMgrInner_:%{public}d or null dataObsMgrInnerExt", - dataObsMgrInner_ == nullptr); + LOG_ERROR("dataObsMgrInner_:%{public}d or null dataObsMgrInnerExt", dataObsMgrInner_ == nullptr); return DATAOBS_SERVICE_INNER_IS_NULL; } if (!IsCallingPermissionValid(opt)) { return DATAOBS_NOT_SYSTEM_APP; } - - int userId = GetCallingUserId(IPCSkeleton::GetCallingTokenID()); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + int userId = GetCallingUserId(tokenId); if (userId == -1) { - TAG_LOGE(AAFwkTag::DBOBSMGR, "GetCallingUserId fail, type:%{public}d, userId:%{public}d", - changeInfo.changeType_, userId); + LOG_ERROR("GetCallingUserId fail, type:%{public}d, userId:%{public}d", changeInfo.changeType_, userId); return DATAOBS_INVALID_USERID; } - ChangeInfo changes; Status result = DeepCopyChangeInfo(changeInfo, changes); if (result != SUCCESS) { - TAG_LOGE(AAFwkTag::DBOBSMGR, - "copy data failed, changeType:%{public}ud,uris num:%{public}zu, " - "null data:%{public}d, size:%{public}ud", + LOG_ERROR("copy data failed,changeType:%{public}ud,uris num:%{public}zu,null data:%{public}d,size:%{public}ud", changeInfo.changeType_, changeInfo.uris_.size(), changeInfo.data_ == nullptr, changeInfo.size_); return result; } - { std::lock_guard lck(taskCountMutex_); if (taskCount_ >= TASK_COUNT_MAX) { - TAG_LOGE(AAFwkTag::DBOBSMGR, - "task num maxed, changeType:%{public}ud," + TAG_LOGE(AAFwkTag::DBOBSMGR, "task num maxed, changeType:%{public}ud," "uris num:%{public}zu, null data:%{public}d, size:%{public}ud", changeInfo.changeType_, changeInfo.uris_.size(), changeInfo.data_ == nullptr, changeInfo.size_); return DATAOBS_SERVICE_TASK_LIMMIT; } ++taskCount_; } - - handler_->SubmitTask([this, changes, userId]() { + handler_->SubmitTask([this, changes, userId, tokenId]() { dataObsMgrInnerExt_->HandleNotifyChange(changes, userId); for (auto &uri : changes.uris_) { + ObserverInfo info(tokenId, 0, 0, userId, false); + info.errMsg = "NotifyChangeExt"; + VerifyDataSharePermissionInner(uri, false, info); dataObsMgrInner_->HandleNotifyChange(uri, userId); } delete [] static_cast(changes.data_); diff --git a/services/dataobsmgr/src/dataobs_mgr_stub.cpp b/services/dataobsmgr/src/dataobs_mgr_stub.cpp index 1877e2d10b1..d882c399894 100644 --- a/services/dataobsmgr/src/dataobs_mgr_stub.cpp +++ b/services/dataobsmgr/src/dataobs_mgr_stub.cpp @@ -38,13 +38,25 @@ const DataObsManagerStub::RequestFuncType DataObsManagerStub::HANDLES[TRANS_BUTT &DataObsManagerStub::UnregisterObserverExtInner, &DataObsManagerStub::UnregisterObserverExtALLInner, &DataObsManagerStub::NotifyChangeExtInner, - &DataObsManagerStub::NotifyProcessObserverInner + &DataObsManagerStub::NotifyProcessObserverInner, + &DataObsManagerStub::RegisterObserverFromExtensionInner, + &DataObsManagerStub::NotifyChangeFromExtensionInner, + &DataObsManagerStub::VerifyWhiteListInner }; DataObsManagerStub::DataObsManagerStub() {} DataObsManagerStub::~DataObsManagerStub() {} +DataObsOption ReadObsOpt(MessageParcel &data) +{ + bool isSystem = data.ReadBool(); + uint32_t token = data.ReadUint32(); + DataObsOption opt(isSystem); + opt.SetFirstCallerTokenID(token); + return opt; +} + int DataObsManagerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { TAG_LOGD(AAFwkTag::DBOBSMGR, "code: %{public}d, flags: %{public}d, callingPid:%{public}d", code, option.GetFlags(), @@ -83,6 +95,23 @@ int DataObsManagerStub::RegisterObserverInner(MessageParcel &data, MessageParcel return NO_ERROR; } +int DataObsManagerStub::RegisterObserverFromExtensionInner(MessageParcel &data, MessageParcel &reply) +{ + Uri uri(data.ReadString()); + if (uri.ToString().empty()) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "invalid uri"); + return IPC_STUB_INVALID_DATA_ERR; + } + + auto remote = data.ReadRemoteObject(); + auto observer = remote == nullptr ? nullptr : iface_cast(remote); + int32_t userId = data.ReadInt32(); + DataObsOption opt = ReadObsOpt(data); + int32_t result = RegisterObserverFromExtension(uri, observer, userId, opt); + reply.WriteInt32(result); + return NO_ERROR; +} + int DataObsManagerStub::UnregisterObserverInner(MessageParcel &data, MessageParcel &reply) { Uri uri(data.ReadString()); @@ -114,6 +143,29 @@ int DataObsManagerStub::NotifyChangeInner(MessageParcel &data, MessageParcel &re return NO_ERROR; } +int DataObsManagerStub::NotifyChangeFromExtensionInner(MessageParcel &data, MessageParcel &reply) +{ + Uri uri(data.ReadString()); + if (uri.ToString().empty()) { + TAG_LOGE(AAFwkTag::DBOBSMGR, "invalid uri"); + return IPC_STUB_INVALID_DATA_ERR; + } + int32_t userId = data.ReadInt32(); + DataObsOption opt = ReadObsOpt(data); + int32_t result = NotifyChangeFromExtension(uri, userId, opt); + reply.WriteInt32(result); + return NO_ERROR; +} + +int DataObsManagerStub::VerifyWhiteListInner(MessageParcel &data, MessageParcel &reply) +{ + int32_t consumerToken = data.ReadInt32(); + int32_t providerToken = data.ReadInt32(); + int32_t result = CheckTrusts(consumerToken, providerToken); + reply.WriteInt32(result); + return NO_ERROR; +} + int32_t DataObsManagerStub::RegisterObserverExtInner(MessageParcel &data, MessageParcel &reply) { Uri uri(data.ReadString()); diff --git a/test/unittest/dataobs_mgr_client_test/mock_dataobs_mgr_service.h b/test/unittest/dataobs_mgr_client_test/mock_dataobs_mgr_service.h index 0099422f27c..fbe7a7586fc 100644 --- a/test/unittest/dataobs_mgr_client_test/mock_dataobs_mgr_service.h +++ b/test/unittest/dataobs_mgr_client_test/mock_dataobs_mgr_service.h @@ -83,6 +83,11 @@ public: return SUCCESS; } + MOCK_METHOD4(RegisterObserverFromExtension, int(const Uri&, sptr, + int32_t userId, DataObsOption opt)); + MOCK_METHOD3(NotifyChangeFromExtension, int(const Uri&, int32_t userId, DataObsOption opt)); + MOCK_METHOD2(CheckTrusts, int(uint32_t consumerToken, uint32_t providerToken)); + void OnStart() {} void OnStop() {} diff --git a/test/unittest/dataobs_mgr_inner_ext_test/dataobs_mgr_inner_ext_test.cpp b/test/unittest/dataobs_mgr_inner_ext_test/dataobs_mgr_inner_ext_test.cpp index f1eaf859f7b..b0ea679bc53 100644 --- a/test/unittest/dataobs_mgr_inner_ext_test/dataobs_mgr_inner_ext_test.cpp +++ b/test/unittest/dataobs_mgr_inner_ext_test/dataobs_mgr_inner_ext_test.cpp @@ -16,6 +16,7 @@ #include #include +#include "dataobs_mgr_inner_common.h" #include "uri.h" #define private public #include "data_ability_observer_proxy.h" @@ -59,7 +60,8 @@ void DataObsMgrInnerExtTest::RegisterObserverUtil(std::shared_ptr &callback, uint32_t times, bool isFuzzy) { while (times-- > 0) { - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, callback, USER_TEST, 0, isFuzzy), SUCCESS); + ObserverInfo info(0, 0, 0, USER_TEST, false); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, callback, info, isFuzzy), SUCCESS); } } @@ -116,8 +118,8 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0100, Uri uri1(uriBase + "/Person"); Uri uri2(uriBase + "/Person/2"); sptr observer(new (std::nothrow) MockDataAbilityObserverStub()); - - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, USER_TEST, 0), SUCCESS); + ObserverInfo info(0, 0, 0, USER_TEST, false); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, info), SUCCESS); ChangeInfo changeInfo = { ChangeInfo::ChangeType::OTHER, {uri1} }; dataObsMgrInnerExt->HandleNotifyChange(changeInfo, USER_TEST); @@ -186,15 +188,15 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0300, sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); sptr observer2(new (std::nothrow) MockDataAbilityObserverStub()); sptr observer3(new (std::nothrow) MockDataAbilityObserverStub()); + ObserverInfo info(0, 0, 0, USER_TEST, false); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2, info), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2, USER_TEST, 0), SUCCESS); - - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer2, USER_TEST, 0), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer3, USER_TEST, 0), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer2, info), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer3, info), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri3, observer3, USER_TEST, 0), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri3, observer1, USER_TEST, 0), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri3, observer3, info), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri3, observer1, info), SUCCESS); dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } }, USER_TEST); EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 })); @@ -231,9 +233,9 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0400, Uri uri123(uriBase + "/Person1/2/3"); Uri uri14(uriBase + "/Person1/4"); Uri uri2(uriBase + "/Person2"); - + ObserverInfo info(0, 0, 0, USER_TEST, false); sptr observer(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, USER_TEST, 0, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, info, true), SUCCESS); dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } }, USER_TEST); EXPECT_TRUE(UrisEqual(observer->changeInfo_.uris_, { uri1 })); @@ -301,13 +303,13 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0600, Uri uri123(uriBase + "/Person1/2/3"); Uri uri14(uriBase + "/Person1/4"); Uri uri145(uriBase + "/Person1/4/5"); - + ObserverInfo info(0, 0, 0, USER_TEST, false); sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0, true), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri123, observer1, USER_TEST, 0, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri123, observer1, info, true), SUCCESS); sptr observer2(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, USER_TEST, 0, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, info, true), SUCCESS); dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } }, USER_TEST); EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 })); @@ -342,13 +344,13 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0700, Uri uri123(uriBase + "/Person1/2/3"); Uri uri14(uriBase + "/Person1/4"); Uri uri145(uriBase + "/Person1/4/5"); - + ObserverInfo info(0, 0, 0, USER_TEST, false); sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, true), SUCCESS); sptr observer2(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, USER_TEST, 0, true), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, USER_TEST, 0, false), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, info, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, info, false), SUCCESS); dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } }, USER_TEST); EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 })); @@ -377,27 +379,28 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0900, Uri uri1(uriBase + "/Person1"); int res = 0; - + ObserverInfo info(0, 0, 0, USER_TEST, false); int times = DataObsMgrInnerExt::OBS_NUM_MAX; for (int i = 0; i <= times; i++) { sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); - res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0, true); + res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, true); EXPECT_EQ(res, SUCCESS); } sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); - res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0, true); + res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, true); EXPECT_EQ(res, DATAOBS_SERVICE_OBS_LIMMIT); TAG_LOGE(AAFwkTag::DBOBSMGR, "DataObsMgrInnerExt_HandleRegisterObserver_0900"); + ObserverInfo info1(1, 0, 0, USER_TEST, false); // other token success sptr observer2(new (std::nothrow) MockDataAbilityObserverStub()); - res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2, USER_TEST, 1, true); + res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2, info1, true); EXPECT_EQ(res, SUCCESS); // other uri success Uri uri12(uriBase + "/Person1/2"); sptr observer3(new (std::nothrow) MockDataAbilityObserverStub()); - res = dataObsMgrInnerExt->HandleRegisterObserver(uri12, observer3, USER_TEST, 0, true); + res = dataObsMgrInnerExt->HandleRegisterObserver(uri12, observer3, info, true); EXPECT_EQ(res, SUCCESS); } @@ -420,13 +423,15 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_01000 for (int token = 0; token < DataObsMgrInnerExt::OBS_NUM_MAX; token++) { for (int i = 0; i < DataObsMgrInnerExt::OBS_NUM_MAX; i++) { + ObserverInfo info(token, 0, 0, USER_TEST, false); sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); - res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, token, true); + res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, true); EXPECT_EQ(res, SUCCESS); } } + ObserverInfo info(0, 0, 0, USER_TEST, false); sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); - res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0, true); + res = dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, true); EXPECT_EQ(res, DATAOBS_SERVICE_OBS_LIMMIT); TAG_LOGE(AAFwkTag::DBOBSMGR, "DataObsMgrInnerExt_HandleRegisterObserver_01000::Start"); } @@ -449,8 +454,9 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleUnregisterObserver_010 Uri uri12(uriBase1 + "/Person1/2"); Uri uri2(uriBase2 + "/Person2"); + ObserverInfo info(0, 0, 0, USER_TEST, false); sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, true), SUCCESS); dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } }, USER_TEST); EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 })); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1); @@ -478,11 +484,12 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleUnregisterObserver_020 sptr observer(new (std::nothrow) MockDataAbilityObserverStub()); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 0); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, USER_TEST, 0, true), SUCCESS); + ObserverInfo info(0, 0, 0, USER_TEST, false); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, info, true), SUCCESS); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.find(observer)->second->ref, 2); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, USER_TEST, 0, false), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, info, false), SUCCESS); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.find(observer)->second->ref, 3); @@ -516,15 +523,15 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleUnregisterObserver_030 Uri uri13(uriBase + "/Person1/3"); Uri uri134(uriBase + "/Person1/3/4"); Uri uri135(uriBase + "/Person1/3/5"); - + ObserverInfo info(0, 0, 0, USER_TEST, false); sptr observer(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer, USER_TEST, 0, true), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer, USER_TEST, 0, false), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri134, observer, USER_TEST, 0, false), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer, info, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer, info, false), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri134, observer, info, false), SUCCESS); sptr observer2(new (std::nothrow) MockDataAbilityObserverStub()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer2, USER_TEST, 0, true), SUCCESS); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri135, observer2, USER_TEST, 0, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer2, info, true), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri135, observer2, info, true), SUCCESS); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 2); EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.find(observer2)->second->ref, 3); @@ -566,14 +573,14 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_RegisterAndUnRegister_0100, sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); sptr observer2(new (std::nothrow) MockDataAbilityObserverStub()); - + ObserverInfo info(0, 0, 0, USER_TEST, false); RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer1, AAFwk::DataObsMgrInnerExt::OBS_NUM_MAX + 1, false); auto obsRecipientRef1 = dataObsMgrInnerExt->obsRecipientRefs.find(observer1); EXPECT_TRUE(obsRecipientRef1 != dataObsMgrInnerExt->obsRecipientRefs.end() && obsRecipientRef1->second->ref == 52); EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer2) == dataObsMgrInnerExt->obsRecipientRefs.end()); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, USER_TEST, 0, false), + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, info, false), DATAOBS_SERVICE_OBS_LIMMIT); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2, USER_TEST, 0, true), + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2, info, true), DATAOBS_SERVICE_OBS_LIMMIT); EXPECT_EQ(obsRecipientRef1->second->ref, 52); EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer2) == dataObsMgrInnerExt->obsRecipientRefs.end()); @@ -608,16 +615,16 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_RegisterAndUnRegister_0200, sptr observer1(new (std::nothrow) MockDataAbilityObserverStub()); sptr observer2(new (std::nothrow) MockDataAbilityObserverStub()); - + ObserverInfo info(0, 0, 0, USER_TEST, false); RegisterObserverUtil(dataObsMgrInnerExt, uri2, observer1, 20, true); RegisterObserverUtil(dataObsMgrInnerExt, uri2, observer2, 31, false); auto obsRecipientRef1 = dataObsMgrInnerExt->obsRecipientRefs.find(observer1); auto obsRecipientRef2 = dataObsMgrInnerExt->obsRecipientRefs.find(observer2); EXPECT_TRUE(obsRecipientRef1 != dataObsMgrInnerExt->obsRecipientRefs.end() && obsRecipientRef1->second->ref == 21); EXPECT_TRUE(obsRecipientRef2 != dataObsMgrInnerExt->obsRecipientRefs.end() && obsRecipientRef2->second->ref == 32); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer1, USER_TEST, 0, false), + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer1, info, false), DATAOBS_SERVICE_OBS_LIMMIT); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer2, USER_TEST, 0, false), + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer2, info, false), DATAOBS_SERVICE_OBS_LIMMIT); EXPECT_EQ(obsRecipientRef1->second->ref, 21); EXPECT_EQ(obsRecipientRef2->second->ref, 32); @@ -757,8 +764,9 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_DeathRecipient_0200, TestSiz sptr deathRecipient = nullptr; sptr observer(new (std::nothrow) MockDataAbilityObserverStub()); { + ObserverInfo info(0, 0, 0, USER_TEST, false); std::shared_ptr dataObsMgrInnerExt = std::make_shared(); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer, USER_TEST, 0, false), SUCCESS); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer, info, false), SUCCESS); auto it = dataObsMgrInnerExt->obsRecipientRefs.find(observer->AsObject()); EXPECT_TRUE(it != dataObsMgrInnerExt->obsRecipientRefs.end() && it->second->deathRecipient != nullptr); @@ -791,7 +799,8 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_AddObsDeathRecipientOverMax_ EXPECT_TRUE(dataObsMgrInnerExt->AddObsDeathRecipient(observer)); deathRecipientRef->ref++; EXPECT_FALSE(dataObsMgrInnerExt->AddObsDeathRecipient(observer)); - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer, USER_TEST, 0), DATAOBS_SERVICE_OBS_LIMMIT); + ObserverInfo info(0, 0, 0, USER_TEST, false); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer, info), DATAOBS_SERVICE_OBS_LIMMIT); } /* @@ -815,7 +824,8 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0800, auto func = [](std::vector &uris, std::shared_ptr obsMgr, sptr &obs) { for (uint32_t i = 0; i < uris.size() * 5; ++i) { - EXPECT_EQ(obsMgr->HandleRegisterObserver(uris[i % uris.size()], obs, USER_TEST, 0, false), SUCCESS); + ObserverInfo info(0, 0, 0, USER_TEST, false); + EXPECT_EQ(obsMgr->HandleRegisterObserver(uris[i % uris.size()], obs, info, false), SUCCESS); } obs->Notify(); }; @@ -862,10 +872,12 @@ HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleNotifyChange_0100, Tes sptr observer1 = (new (std::nothrow) MockDataAbilityObserverStub()); sptr observer2 = (new (std::nothrow) MockDataAbilityObserverStub()); - dataObsMgrInnerExt->HandleRegisterObserver(uri, observer1, USER_TEST, 0); + ObserverInfo info(0, 0, 0, USER_TEST, false); + dataObsMgrInnerExt->HandleRegisterObserver(uri, observer1, info); observer1->func = [&dataObsMgrInnerExt, &observer2, &uri]() { - EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer2, USER_TEST, 0), SUCCESS); + ObserverInfo info(0, 0, 0, USER_TEST, false); + EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer2, info), SUCCESS); }; EXPECT_EQ(dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri } }, USER_TEST), SUCCESS); EXPECT_EQ(observer1->onChangeCall_, 1); diff --git a/test/unittest/dataobs_mgr_proxy_test/mock_data_obs_mgr_stub.h b/test/unittest/dataobs_mgr_proxy_test/mock_data_obs_mgr_stub.h index a0a80be0962..7e2fa8a0b80 100644 --- a/test/unittest/dataobs_mgr_proxy_test/mock_data_obs_mgr_stub.h +++ b/test/unittest/dataobs_mgr_proxy_test/mock_data_obs_mgr_stub.h @@ -46,6 +46,10 @@ public: MOCK_METHOD2(UnregisterObserverExt, Status(sptr, DataObsOption)); MOCK_METHOD2(NotifyChangeExt, Status(const ChangeInfo&, DataObsOption)); MOCK_METHOD3(NotifyProcessObserver, Status(const std::string&, const sptr&, DataObsOption)); + MOCK_METHOD4(RegisterObserverFromExtension, int(const Uri&, sptr, + int32_t userId, DataObsOption opt)); + MOCK_METHOD3(NotifyChangeFromExtension, int(const Uri&, int32_t userId, DataObsOption opt)); + MOCK_METHOD2(CheckTrusts, int(uint32_t consumerToken, uint32_t providerToken)); }; class MockDataAbilityObserverStub : public AAFwk::DataAbilityObserverStub { diff --git a/test/unittest/dataobs_mgr_service_test/BUILD.gn b/test/unittest/dataobs_mgr_service_test/BUILD.gn index 45110836b3f..32e9ad7b63d 100644 --- a/test/unittest/dataobs_mgr_service_test/BUILD.gn +++ b/test/unittest/dataobs_mgr_service_test/BUILD.gn @@ -51,6 +51,7 @@ ohos_unittest("dataobs_mgr_service_test") { "access_token:libtoken_setproc", "access_token:libaccesstoken_sdk", "c_utils:utils", + "data_share:datashare_permission", "ffrt:libffrt", "googletest:gmock_main", "googletest:gtest_main", diff --git a/test/unittest/dataobs_mgr_service_test/dataobs_mgr_service_test.cpp b/test/unittest/dataobs_mgr_service_test/dataobs_mgr_service_test.cpp index f5e72e0d697..619c0066005 100644 --- a/test/unittest/dataobs_mgr_service_test/dataobs_mgr_service_test.cpp +++ b/test/unittest/dataobs_mgr_service_test/dataobs_mgr_service_test.cpp @@ -17,17 +17,20 @@ #include "gtest/gtest.h" #include "gmock/gmock.h" -#include "access_token.h" -#include "dataobs_mgr_interface.h" +#include "access_token.h" +#include "accesstoken_kit.h" +#include "dataobs_mgr_interface.h" +#include "datashare_errno.h" #include "mock_data_ability_observer_stub.h" #include "token_setproc.h" #define private public #include "dataobs_mgr_service.h" -#include "hilog_tag_wrapper.h" +#include "hilog_tag_wrapper.h" namespace OHOS { namespace AAFwk { using namespace testing::ext; +static int USER_100 = 100; class DataObsMgrServiceTest : public testing::Test { public: DataObsMgrServiceTest() = default; @@ -153,17 +156,17 @@ HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_RegisterObserver_040 SetSelfTokenID(0); std::shared_ptr uri = std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); - auto dataObsMgrServer = std::make_shared(); + auto dataObsMgrServer = std::make_shared(); EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserver(*uri, dataobsAbility)); dataObsMgrServer->dataObsMgrInner_ = std::make_shared(); testing::Mock::AllowLeak(dataobsAbility); - int count = 0; - ON_CALL(*dataobsAbility, OnChange()).WillByDefault(testing::Invoke([&count]() { - count++; - })); - dataObsMgrServer->NotifyChange(*uri); - EXPECT_EQ(count, 0); + int count = 0; + ON_CALL(*dataobsAbility, OnChange()).WillByDefault(testing::Invoke([&count]() { + count++; + })); + dataObsMgrServer->NotifyChange(*uri); + EXPECT_EQ(count, 0); SetSelfTokenID(originalToken); GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0300 end"; @@ -636,42 +639,42 @@ HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_Dump_0100, TestSize. */ HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100, TestSize.Level1) { - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100 start"); - auto dataObsMgrServer = std::make_shared(); - auto originalToken = GetSelfTokenID(); - - // set system app - uint64_t systemAppMask = (static_cast(1) << 32); - uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; - Security::AccessToken::AccessTokenIDInner *idInner = - reinterpret_cast(&tokenID); - idInner->type = Security::AccessToken::TOKEN_HAP; - uint64_t fullTokenId = systemAppMask | tokenID; - SetSelfTokenID(fullTokenId); + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100 start"); + auto dataObsMgrServer = std::make_shared(); + auto originalToken = GetSelfTokenID(); + + // set system app + uint64_t systemAppMask = (static_cast(1) << 32); + uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; + Security::AccessToken::AccessTokenIDInner *idInner = + reinterpret_cast(&tokenID); + idInner->type = Security::AccessToken::TOKEN_HAP; + uint64_t fullTokenId = systemAppMask | tokenID; + SetSelfTokenID(fullTokenId); DataObsOption opt; - bool ret = 0; + bool ret = 0; opt.isSystem = true; - ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1); - EXPECT_EQ(ret, false); - ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1); + EXPECT_EQ(ret, false); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); EXPECT_EQ(ret, true); - ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101); EXPECT_EQ(ret, true); - ret = dataObsMgrServer->IsCallingPermissionValid(opt); + ret = dataObsMgrServer->IsCallingPermissionValid(opt); EXPECT_EQ(ret, true); - + opt.isSystem = false; - ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1); - EXPECT_EQ(ret, false); - ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); - EXPECT_EQ(ret, true); - ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1); + EXPECT_EQ(ret, false); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); EXPECT_EQ(ret, true); - ret = dataObsMgrServer->IsCallingPermissionValid(opt); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101); + EXPECT_EQ(ret, true); + ret = dataObsMgrServer->IsCallingPermissionValid(opt); EXPECT_EQ(ret, true); - SetSelfTokenID(originalToken); - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100 end"); + SetSelfTokenID(originalToken); + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100 end"); } /* @@ -684,93 +687,105 @@ HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_CheckSystemCallingPe */ HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200, TestSize.Level1) { - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200 start"); - auto dataObsMgrServer = std::make_shared(); + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200 start"); + auto dataObsMgrServer = std::make_shared(); auto originalToken = GetSelfTokenID(); - // set token native - uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; - Security::AccessToken::AccessTokenIDInner *idInner = - reinterpret_cast(&tokenID); - idInner->type = Security::AccessToken::TOKEN_NATIVE; - SetSelfTokenID(tokenID); - + // set token native + uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; + Security::AccessToken::AccessTokenIDInner *idInner = + reinterpret_cast(&tokenID); + idInner->type = Security::AccessToken::TOKEN_NATIVE; + SetSelfTokenID(tokenID); + DataObsOption opt; - bool ret = 0; - opt.isSystem = false; - ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1); - EXPECT_EQ(ret, false); - ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); - EXPECT_EQ(ret, true); - ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101); + bool ret = 0; + opt.isSystem = false; + ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1); + EXPECT_EQ(ret, false); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); + EXPECT_EQ(ret, true); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101); EXPECT_EQ(ret, false); opt.isSystem = true; - ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); + ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100); + EXPECT_EQ(ret, false); + + SetSelfTokenID(originalToken); + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200 end"); +} + +/* + * Feature: DataObsMgrService + * Function: GetDataMgrServiceUid + * SubFunction: NA + * FunctionPoints: DataObsMgrService GetDataMgrServiceUid + * EnvConditions: NA + * CaseDescription: Verify that the DataObsMgrService GetDataMgrServiceUid is normal. + */ +HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100 start"); + auto dataObsMgrServer = std::make_shared(); + + auto uid1 = dataObsMgrServer->GetDataMgrServiceUid(); + EXPECT_NE(uid1, 0); + auto uid2 = dataObsMgrServer->GetDataMgrServiceUid(); + EXPECT_EQ(uid1, uid2); + + uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; + Security::AccessToken::AccessTokenIDInner *idInner = + reinterpret_cast(&tokenID); + idInner->type = Security::AccessToken::TOKEN_NATIVE; + bool ret = dataObsMgrServer->IsDataMgrService(tokenID, uid1); + EXPECT_EQ(ret, true); + idInner->type = Security::AccessToken::TOKEN_HAP; + ret = dataObsMgrServer->IsDataMgrService(tokenID, uid1); EXPECT_EQ(ret, false); - - SetSelfTokenID(originalToken); - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200 end"); -} - -/* - * Feature: DataObsMgrService - * Function: GetDataMgrServiceUid - * SubFunction: NA - * FunctionPoints: DataObsMgrService GetDataMgrServiceUid - * EnvConditions: NA - * CaseDescription: Verify that the DataObsMgrService GetDataMgrServiceUid is normal. - */ -HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100, TestSize.Level1) -{ - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100 start"); - auto dataObsMgrServer = std::make_shared(); - - auto uid1 = dataObsMgrServer->GetDataMgrServiceUid(); - EXPECT_NE(uid1, 0); - auto uid2 = dataObsMgrServer->GetDataMgrServiceUid(); - EXPECT_EQ(uid1, uid2); - - uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; - Security::AccessToken::AccessTokenIDInner *idInner = - reinterpret_cast(&tokenID); - idInner->type = Security::AccessToken::TOKEN_NATIVE; - bool ret = dataObsMgrServer->IsDataMgrService(tokenID, uid1); + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100 end"); +} + +/* + * Feature: DataObsMgrService + * Function: GetDataMgrServiceUid + * SubFunction: NA + * FunctionPoints: DataObsMgrService GetDataMgrServiceUid + * EnvConditions: NA + * CaseDescription: Verify that the DataObsMgrService IsSystemApp is normal. + */ +HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_IsSystemApp_0100, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_IsSystemApp_0100 start"); + auto dataObsMgrServer = std::make_shared(); + auto originalToken = GetSelfTokenID(); + + // set system app + uint64_t systemAppMask = (static_cast(1) << 32); + uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; + Security::AccessToken::AccessTokenIDInner *idInner = + reinterpret_cast(&tokenID); + idInner->type = Security::AccessToken::TOKEN_HAP; + uint64_t fullTokenId = systemAppMask | tokenID; + + bool ret = dataObsMgrServer->IsSystemApp(tokenID, fullTokenId); EXPECT_EQ(ret, true); - idInner->type = Security::AccessToken::TOKEN_HAP; - ret = dataObsMgrServer->IsDataMgrService(tokenID, uid1); + idInner->type = Security::AccessToken::TOKEN_NATIVE; + ret = dataObsMgrServer->IsSystemApp(tokenID, fullTokenId); EXPECT_EQ(ret, false); - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100 end"); -} - -/* - * Feature: DataObsMgrService - * Function: GetDataMgrServiceUid - * SubFunction: NA - * FunctionPoints: DataObsMgrService GetDataMgrServiceUid - * EnvConditions: NA - * CaseDescription: Verify that the DataObsMgrService IsSystemApp is normal. - */ -HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_IsSystemApp_0100, TestSize.Level1) -{ - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_IsSystemApp_0100 start"); - auto dataObsMgrServer = std::make_shared(); - auto originalToken = GetSelfTokenID(); - - // set system app - uint64_t systemAppMask = (static_cast(1) << 32); - uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION; - Security::AccessToken::AccessTokenIDInner *idInner = - reinterpret_cast(&tokenID); - idInner->type = Security::AccessToken::TOKEN_HAP; - uint64_t fullTokenId = systemAppMask | tokenID; - - bool ret = dataObsMgrServer->IsSystemApp(tokenID, fullTokenId); - EXPECT_EQ(ret, true); - idInner->type = Security::AccessToken::TOKEN_NATIVE; - ret = dataObsMgrServer->IsSystemApp(tokenID, fullTokenId); - EXPECT_EQ(ret, false); - TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_IsSystemApp_0100 end"); + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_IsSystemApp_0100 end"); } - + +HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_VerifyDataSharePermission_0100, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_VerifyDataSharePermission_0100 start"); + auto dataObsMgrServer = std::make_shared(); + std::string proxyUriOk = "datashareproxy://com.acts.datasharetest/test"; + Uri uri(proxyUriOk); + ObserverInfo info(0, 0, 0, 0, true); + int32_t ret = dataObsMgrServer->VerifyDataSharePermission(uri, true, info); + EXPECT_EQ(ret, DataShare::E_NOT_HAP); + TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_VerifyDataSharePermission_0100 end"); +} + } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/dataobs_mgr_stub_test/mock_data_obs_mgr_stub.h b/test/unittest/dataobs_mgr_stub_test/mock_data_obs_mgr_stub.h index 4b4d67c7faa..60c4dac61e9 100644 --- a/test/unittest/dataobs_mgr_stub_test/mock_data_obs_mgr_stub.h +++ b/test/unittest/dataobs_mgr_stub_test/mock_data_obs_mgr_stub.h @@ -44,6 +44,10 @@ public: MOCK_METHOD2(UnregisterObserverExt, Status(sptr, DataObsOption opt)); MOCK_METHOD2(NotifyChangeExt, Status(const ChangeInfo&, DataObsOption opt)); MOCK_METHOD3(NotifyProcessObserver, Status(const std::string&, const sptr&, DataObsOption opt)); + MOCK_METHOD4(RegisterObserverFromExtension, int(const Uri&, sptr, + int32_t userId, DataObsOption opt)); + MOCK_METHOD3(NotifyChangeFromExtension, int(const Uri&, int32_t userId, DataObsOption opt)); + MOCK_METHOD2(CheckTrusts, int(uint32_t consumerToken, uint32_t providerToken)); }; class MockDataAbilityObserverStub : public AAFwk::DataAbilityObserverStub { -- Gitee