From 87aed69676759fbbf47abb172ddf081392db433c Mon Sep 17 00:00:00 2001 From: duansizhao Date: Sat, 23 Sep 2023 07:18:10 +0000 Subject: [PATCH] =?UTF-8?q?=E6=94=AF=E6=8C=81=E6=89=B9=E9=87=8F=E6=8E=88?= =?UTF-8?q?=E6=9D=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: duansizhao Change-Id: Ia04fcc59665be2a266f83ca16cabe505ab5f2b0a --- .../include/uri_permission_manager_client.h | 11 ++ .../uri_permission_manager_interface.h | 17 +- .../include/uri_permission_manager_proxy.h | 4 + .../include/uri_permission_manager_stub.h | 1 + .../src/uri_permission_manager_client.cpp | 17 +- .../src/uri_permission_manager_proxy.cpp | 45 +++++ .../src/uri_permission_manager_stub.cpp | 31 ++++ .../src/ability_connect_manager.cpp | 1 + services/abilitymgr/src/ability_record.cpp | 29 +++- .../uri_permission_manager_stub_impl.h | 14 ++ .../src/uri_permission_manager_stub_impl.cpp | 163 +++++++++++++++--- .../include/storage_manager_service_mock.h | 19 +- .../include/storage_manager_service_mock.h | 19 +- 13 files changed, 332 insertions(+), 39 deletions(-) diff --git a/interfaces/inner_api/uri_permission/include/uri_permission_manager_client.h b/interfaces/inner_api/uri_permission/include/uri_permission_manager_client.h index 44932f501f..ea25f6b9c8 100644 --- a/interfaces/inner_api/uri_permission/include/uri_permission_manager_client.h +++ b/interfaces/inner_api/uri_permission/include/uri_permission_manager_client.h @@ -40,6 +40,17 @@ public: int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName, int autoremove, int32_t appIndex = 0); + /** + * @brief Authorize the uri permission of to targetBundleName. + * + * @param uriVec The file uri list. + * @param flag Want::FLAG_AUTH_READ_URI_PERMISSION or Want::FLAG_AUTH_WRITE_URI_PERMISSION. + * @param targetBundleName The user of uri. + * @param autoremove the uri is temperarily or not + */ + int GrantUriPermission(const std::vector &uriVec, unsigned int flag, + const std::string targetBundleName, int autoremove, int32_t appIndex = 0); + /** * @brief Clear user's uri authorization record with auto remove flag. * diff --git a/interfaces/inner_api/uri_permission/include/uri_permission_manager_interface.h b/interfaces/inner_api/uri_permission/include/uri_permission_manager_interface.h index ee5e8ea08a..1786e05473 100644 --- a/interfaces/inner_api/uri_permission/include/uri_permission_manager_interface.h +++ b/interfaces/inner_api/uri_permission/include/uri_permission_manager_interface.h @@ -15,7 +15,7 @@ #ifndef OHOS_ABILITY_RUNTIME_URI_PERMISSION_MANAGER_INTERFACE_H #define OHOS_ABILITY_RUNTIME_URI_PERMISSION_MANAGER_INTERFACE_H - +#include #include "base/security/access_token/interfaces/innerkits/accesstoken/include/access_token.h" #include "iremote_broker.h" #include "uri.h" @@ -38,6 +38,18 @@ public: virtual int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName, int autoremove, int32_t appIndex = 0) = 0; + /** + * @brief Authorize the uri permission to targetBundleName. + * + * @param uriVec The file urilist. + * @param flag Want::FLAG_AUTH_READ_URI_PERMISSION or Want::FLAG_AUTH_WRITE_URI_PERMISSION. + * @param targetBundleName The user of uri. + * @param autoremove the uri is temperarily or not + * @return Returns true if the authorization is successful, otherwise returns false. + */ + virtual int GrantUriPermission(const std::vector &uriVec, unsigned int flag, + const std::string targetBundleName, int autoremove, int32_t appIndex = 0) = 0; + /** * @brief Clear user's uri authorization record with autoremove flag. * @@ -98,6 +110,9 @@ public: // ipc id for VerifyUriPermission ON_VERIFY_URI_PERMISSION, + + // ipc id for BatchGrantUriPermission + ON_BATCH_GRANT_URI_PERMISSION, }; }; } // namespace AAFwk diff --git a/interfaces/inner_api/uri_permission/include/uri_permission_manager_proxy.h b/interfaces/inner_api/uri_permission/include/uri_permission_manager_proxy.h index 71f2c381c5..a67d8fde69 100644 --- a/interfaces/inner_api/uri_permission/include/uri_permission_manager_proxy.h +++ b/interfaces/inner_api/uri_permission/include/uri_permission_manager_proxy.h @@ -16,6 +16,7 @@ #ifndef OHOS_ABILITY_RUNTIME_URI_PERMISSION_MANAGER_PROXY_H #define OHOS_ABILITY_RUNTIME_URI_PERMISSION_MANAGER_PROXY_H +#include #include "iremote_proxy.h" #include "uri_permission_manager_interface.h" @@ -29,6 +30,9 @@ public: virtual int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName, int autoremove, int32_t appIndex = 0) override; + virtual int GrantUriPermission(const std::vector &uriVec, unsigned int flag, + const std::string targetBundleName, int autoremove, int32_t appIndex = 0) override; + virtual void RevokeUriPermission(const Security::AccessToken::AccessTokenID tokenId) override; virtual int RevokeAllUriPermissions(const Security::AccessToken::AccessTokenID tokenId) override; virtual int RevokeUriPermissionManually(const Uri &uri, const std::string bundleName) override; diff --git a/interfaces/inner_api/uri_permission/include/uri_permission_manager_stub.h b/interfaces/inner_api/uri_permission/include/uri_permission_manager_stub.h index b9fd7710d1..6913099262 100644 --- a/interfaces/inner_api/uri_permission/include/uri_permission_manager_stub.h +++ b/interfaces/inner_api/uri_permission/include/uri_permission_manager_stub.h @@ -38,6 +38,7 @@ private: int HandleRevokeUriPermission(MessageParcel &data, MessageParcel &reply); int HandleRevokeAllUriPermission(MessageParcel &data, MessageParcel &reply); int HandleGrantUriPermission(MessageParcel &data, MessageParcel &reply); + int HandleBatchGrantUriPermission(MessageParcel &data, MessageParcel &reply); int HandleRevokeUriPermissionManually(MessageParcel &data, MessageParcel &reply); int HandleCheckPerSiSTableUriPermissionProxy(MessageParcel &data, MessageParcel &reply); int HandleVerifyUriPermission(MessageParcel &data, MessageParcel &reply); diff --git a/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp b/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp index d19c896507..10c67875f8 100644 --- a/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp +++ b/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp @@ -26,6 +26,7 @@ namespace OHOS { namespace AAFwk { namespace { const int LOAD_SA_TIMEOUT_MS = 4 * 1000; +const int MAX_URI_COUNT = 500; } // namespace UriPermissionManagerClient& UriPermissionManagerClient::GetInstance() { @@ -41,7 +42,21 @@ int UriPermissionManagerClient::GrantUriPermission(const Uri &uri, unsigned int if (uriPermMgr) { return uriPermMgr->GrantUriPermission(uri, flag, targetBundleName, autoremove, appIndex); } - + return INNER_ERR; +} + +int UriPermissionManagerClient::GrantUriPermission(const std::vector &uriVec, unsigned int flag, + const std::string targetBundleName, int autoremove, int32_t appIndex) +{ + HILOG_DEBUG("targetBundleName: %{public}s, uriVec size: %{public}zu", targetBundleName.c_str(), uriVec.size()); + if (uriVec.size() == 0 || uriVec.size() > MAX_URI_COUNT) { + HILOG_ERROR("The size of uriVec should be between 1 and %{public}i.", MAX_URI_COUNT); + return INNER_ERR; + } + auto uriPermMgr = ConnectUriPermService(); + if (uriPermMgr) { + return uriPermMgr->GrantUriPermission(uriVec, flag, targetBundleName, autoremove, appIndex); + } return INNER_ERR; } diff --git a/interfaces/inner_api/uri_permission/src/uri_permission_manager_proxy.cpp b/interfaces/inner_api/uri_permission/src/uri_permission_manager_proxy.cpp index 9d875a8f12..a0736a88cc 100644 --- a/interfaces/inner_api/uri_permission/src/uri_permission_manager_proxy.cpp +++ b/interfaces/inner_api/uri_permission/src/uri_permission_manager_proxy.cpp @@ -63,6 +63,51 @@ int UriPermissionManagerProxy::GrantUriPermission(const Uri &uri, unsigned int f return reply.ReadInt32(); } +int UriPermissionManagerProxy::GrantUriPermission(const std::vector &uriVec, unsigned int flag, + const std::string targetBundleName, int autoremove, int32_t appIndex) +{ + HILOG_DEBUG("UriPermissionManagerProxy::GrantUriPermission is called."); + MessageParcel data; + if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) { + HILOG_ERROR("Write interface token failed."); + return INNER_ERR; + } + if (!data.WriteUint32(uriVec.size())) { + HILOG_ERROR("Write size of uriVec failed."); + return INNER_ERR; + } + for (const auto &uri : uriVec) { + if (!data.WriteParcelable(&uri)) { + HILOG_ERROR("Write uri failed."); + return INNER_ERR; + } + } + if (!data.WriteInt32(flag)) { + HILOG_ERROR("Write flag failed."); + return INNER_ERR; + } + if (!data.WriteString(targetBundleName)) { + HILOG_ERROR("Write targetBundleName failed."); + return INNER_ERR; + } + if (!data.WriteInt32(autoremove)) { + HILOG_ERROR("Write autoremove failed."); + return INNER_ERR; + } + if (!data.WriteInt32(appIndex)) { + HILOG_ERROR("Write appIndex failed."); + return INNER_ERR; + } + MessageParcel reply; + MessageOption option; + int error = Remote()->SendRequest(UriPermMgrCmd::ON_BATCH_GRANT_URI_PERMISSION, data, reply, option); + if (error != ERR_OK) { + HILOG_ERROR("SendRequest fial, error: %{public}d", error); + return INNER_ERR; + } + return reply.ReadInt32(); +} + void UriPermissionManagerProxy::RevokeUriPermission(const Security::AccessToken::AccessTokenID tokenId) { HILOG_DEBUG("UriPermissionManagerProxy::RevokeUriPermission is called."); diff --git a/interfaces/inner_api/uri_permission/src/uri_permission_manager_stub.cpp b/interfaces/inner_api/uri_permission/src/uri_permission_manager_stub.cpp index e3b62f43b0..ba111563b2 100644 --- a/interfaces/inner_api/uri_permission/src/uri_permission_manager_stub.cpp +++ b/interfaces/inner_api/uri_permission/src/uri_permission_manager_stub.cpp @@ -19,6 +19,9 @@ namespace OHOS { namespace AAFwk { +namespace { +const int MAX_URI_COUNT = 500; +} int UriPermissionManagerStub::OnRemoteRequest( uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { @@ -31,6 +34,9 @@ int UriPermissionManagerStub::OnRemoteRequest( case UriPermMgrCmd::ON_GRANT_URI_PERMISSION : { return HandleGrantUriPermission(data, reply); } + case UriPermMgrCmd::ON_BATCH_GRANT_URI_PERMISSION : { + return HandleBatchGrantUriPermission(data, reply); + } case UriPermMgrCmd::ON_REVOKE_URI_PERMISSION : { return HandleRevokeUriPermission(data, reply); } @@ -83,6 +89,31 @@ int UriPermissionManagerStub::HandleGrantUriPermission(MessageParcel &data, Mess return ERR_OK; } +int UriPermissionManagerStub::HandleBatchGrantUriPermission(MessageParcel &data, MessageParcel &reply) +{ + auto size = data.ReadUint32(); + if (size <= 0 || size > MAX_URI_COUNT) { + HILOG_ERROR("size is invalid."); + return ERR_DEAD_OBJECT; + } + std::vector uriVec; + for (auto i = 0; i < size; i++) { + std::unique_ptr uri(data.ReadParcelable()); + if (!uri) { + HILOG_ERROR("To read uri failed."); + return ERR_DEAD_OBJECT; + } + uriVec.emplace_back(*uri); + } + auto flag = data.ReadInt32(); + auto targetBundleName = data.ReadString(); + auto autoremove = data.ReadInt32(); + auto appIndex = data.ReadInt32(); + int result = GrantUriPermission(uriVec, flag, targetBundleName, autoremove, appIndex); + reply.WriteInt32(result); + return ERR_OK; +} + int UriPermissionManagerStub::HandleRevokeUriPermissionManually(MessageParcel &data, MessageParcel &reply) { std::unique_ptr uri(data.ReadParcelable()); diff --git a/services/abilitymgr/src/ability_connect_manager.cpp b/services/abilitymgr/src/ability_connect_manager.cpp index 26d8df17f4..15723cabb1 100644 --- a/services/abilitymgr/src/ability_connect_manager.cpp +++ b/services/abilitymgr/src/ability_connect_manager.cpp @@ -1286,6 +1286,7 @@ void AbilityConnectManager::TerminateDone(const std::shared_ptr & "Transition life state error. expect %{public}s, actual %{public}s", expect.c_str(), actual.c_str()); return; } + IN_PROCESS_CALL_WITHOUT_RET(abilityRecord->RevokeUriPermission()); abilityRecord->RemoveAbilityDeathRecipient(); DelayedSingleton::GetInstance()->TerminateAbility(abilityRecord->GetToken(), false); RemoveServiceAbility(abilityRecord); diff --git a/services/abilitymgr/src/ability_record.cpp b/services/abilitymgr/src/ability_record.cpp index ea2f3b49bf..cbb6a264d1 100644 --- a/services/abilitymgr/src/ability_record.cpp +++ b/services/abilitymgr/src/ability_record.cpp @@ -17,6 +17,7 @@ #include #include +#include #include "constants.h" #include "ability_event_handler.h" @@ -84,6 +85,7 @@ const int VECTOR_SIZE = 2; const int LOAD_TIMEOUT_ASANENABLED = 150; const int TERMINATE_TIMEOUT_ASANENABLED = 150; const int HALF_TIMEOUT = 2; +const int MAX_URI_COUNT = 500; #ifdef SUPPORT_ASAN const int COLDSTART_TIMEOUT_MULTIPLE = 15000; const int LOAD_TIMEOUT_MULTIPLE = 15000; @@ -379,6 +381,8 @@ void AbilityRecord::ForegroundAbility(const Closure &task, uint32_t sceneFlag) HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("name:%{public}s.", abilityInfo_.name.c_str()); CHECK_POINTER(lifecycleDeal_); + // grant uri permission + GrantUriPermission(want_, applicationInfo_.bundleName, false, 0); auto handler = DelayedSingleton::GetInstance()->GetTaskHandler(); if (handler && task) { @@ -2600,8 +2604,17 @@ void AbilityRecord::GrantUriPermission(Want &want, std::string targetBundleName, std::vector uriVec; std::string uriStr = want.GetUri().ToString(); uriVec = want.GetStringArrayParam(AbilityConfig::PARAMS_STREAM); - uriVec.emplace_back(uriStr); + if (!uriStr.empty()) { + uriVec.emplace_back(uriStr); + } HILOG_DEBUG("GrantUriPermission uriVec size: %{public}zu", uriVec.size()); + if (uriVec.size() == 0) { + return; + } + if (uriVec.size() > MAX_URI_COUNT) { + HILOG_ERROR("size of uriVec is more than %{public}i", MAX_URI_COUNT); + return; + } auto bundleFlag = AppExecFwk::BundleFlag::GET_BUNDLE_WITH_EXTENSION_INFO; uint32_t fromTokenId = 0; if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { @@ -2615,6 +2628,7 @@ void AbilityRecord::GrantUriPermission(Want &want, std::string targetBundleName, PermissionVerification::GetInstance()->VerifyPermissionByTokenId(tokenId, PERMISSION_PROXY_AUTHORIZATION_URI); auto userId = GetCurrentAccountId(); auto callerTokenId = static_cast(want.GetIntParam(Want::PARAM_RESV_CALLER_TOKEN, -1)); + std::unordered_map> uriVecMap; // flag, vector for (auto&& str : uriVec) { Uri uri(str); auto&& scheme = uri.GetScheme(); @@ -2660,11 +2674,18 @@ void AbilityRecord::GrantUriPermission(Want &want, std::string targetBundleName, } flag &= (~Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION); } - int autoremove = 1; + if (uriVecMap.find(flag) == uriVecMap.end()) { + std::vector uriVec; + uriVecMap.emplace(flag, uriVec); + } + uriVecMap[flag].emplace_back(uri); + } + int autoremove = 1; + for (const auto &item : uriVecMap) { auto ret = IN_PROCESS_CALL( - AAFwk::UriPermissionManagerClient::GetInstance().GrantUriPermission(uri, flag, + AAFwk::UriPermissionManagerClient::GetInstance().GrantUriPermission(item.second, item.first, targetBundleName, autoremove, appIndex_)); - if (ret == 0) { + if (ret == ERR_OK) { isGrantedUriPermission_ = true; } } diff --git a/services/uripermmgr/include/uri_permission_manager_stub_impl.h b/services/uripermmgr/include/uri_permission_manager_stub_impl.h index b8c6610309..55ab6e3077 100644 --- a/services/uripermmgr/include/uri_permission_manager_stub_impl.h +++ b/services/uripermmgr/include/uri_permission_manager_stub_impl.h @@ -18,6 +18,7 @@ #include #include +#include #include "app_mgr_interface.h" #include "bundlemgr/bundle_mgr_interface.h" @@ -47,6 +48,8 @@ public: int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName, int autoremove, int32_t appIndex = 0) override; + int GrantUriPermission(const std::vector &uriVec, unsigned int flag, + const std::string targetBundleName, int autoremove, int32_t appIndex = 0) override; void RevokeUriPermission(const TokenId tokenId) override; int RevokeAllUriPermissions(uint32_t tokenId) override; int RevokeUriPermissionManually(const Uri &uri, const std::string bundleName) override; @@ -69,6 +72,17 @@ private: int DeletTempUriPermission(const std::string &uri, uint32_t flag, uint32_t targetTokenId); int DeletTempUriPermissionAndShareFile(const std::string &uri, uint32_t targetTokenId); + void GetUriPermissionBatchFlag(const std::vector &uriVec, + unsigned int flag, uint32_t targetTokenId, + std::unordered_map> &uriVecMap, + std::unordered_map> &fromTokenIdVecMap); + + int GrantBatchUriPermissionImpl(const std::vector &uriVec, unsigned int flag, + std::vector &fromTokenIdVec, TokenId targetTokenId, int autoremove); + + int GrantSingleUriPermission(const Uri &uri, unsigned int flag, + const std::string &targetBundleName, int autoremove, int32_t appIndex); + void InitPersistableUriPermissionConfig(); class ProxyDeathRecipient : public IRemoteObject::DeathRecipient { diff --git a/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp b/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp index 71e3222bef..bb9d943e9c 100644 --- a/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp +++ b/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp @@ -15,6 +15,8 @@ #include "uri_permission_manager_stub_impl.h" +#include + #include "ability_manager_errors.h" #include "accesstoken_kit.h" #include "hilog_wrapper.h" @@ -89,6 +91,14 @@ int UriPermissionManagerStubImpl::GrantUriPermission(const Uri &uri, unsigned in const std::string targetBundleName, int autoremove, int32_t appIndex) { HILOG_DEBUG("CALL: appIndex is %{public}d.", appIndex); + std::vector uriVec = { uri }; + return GrantUriPermission(uriVec, flag, targetBundleName, autoremove, appIndex); +} + +int UriPermissionManagerStubImpl::GrantUriPermission(const std::vector &uriVec, unsigned int flag, + const std::string targetBundleName, int autoremove, int32_t appIndex) +{ + HILOG_DEBUG("CALL: appIndex is %{public}d, uriVec size is %{public}zu", appIndex, uriVec.size()); // reject sandbox to grant uri permission ConnectManager(appMgr_, APP_MGR_SERVICE_ID); if (appMgr_ == nullptr) { @@ -111,29 +121,35 @@ int UriPermissionManagerStubImpl::GrantUriPermission(const Uri &uri, unsigned in HILOG_WARN("UriPermissionManagerStubImpl::GrantUriPermission: The param flag is invalid."); return ERR_CODE_INVALID_URI_FLAG; } - Uri uri_inner = uri; - auto&& scheme = uri_inner.GetScheme(); - if (scheme != "file") { - HILOG_WARN("only support file uri."); - return ERR_CODE_INVALID_URI_TYPE; - } - auto&& authority = uri_inner.GetAuthority(); - auto fromTokenId = GetTokenIdByBundleName(authority, 0); - auto targetTokenId = GetTokenIdByBundleName(targetBundleName, appIndex); auto callerTokenId = IPCSkeleton::GetCallingTokenID(); - unsigned int tmpFlag = 0; - ret = GetUriPermissionFlag(uri, flag, fromTokenId, targetTokenId, tmpFlag); - if (ret != ERR_OK || tmpFlag == 0) { - return ret; - } - // auto remove URI permission for clipboard + auto targetTokenId = GetTokenIdByBundleName(targetBundleName, appIndex); Security::AccessToken::NativeTokenInfo nativeInfo; Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(callerTokenId, nativeInfo); + // autoremove will be set to 1 if the process name is foundation. HILOG_DEBUG("callerprocessName : %{public}s", nativeInfo.processName.c_str()); - if (nativeInfo.processName == "pasteboard_serv") { + if (nativeInfo.processName == "foundation") { autoremove = 1; } - return GrantUriPermissionImpl(uri, tmpFlag, fromTokenId, targetTokenId, autoremove); + // reserve origin process + if (uriVec.size() == 1) { + return GrantSingleUriPermission(uriVec[0], flag, targetBundleName, autoremove, appIndex); + } + std::unordered_map> uriVecMap; + std::unordered_map> fromTokenIdVecMap; + GetUriPermissionBatchFlag(uriVec, flag, targetTokenId, uriVecMap, fromTokenIdVecMap); + if (uriVecMap.empty()) { + HILOG_DEBUG("uriVecMap is empty"); + return INNER_ERR; + } + ret = INNER_ERR; + for (const auto &item : uriVecMap) { + auto tempRet = GrantBatchUriPermissionImpl(item.second, item.first, fromTokenIdVecMap[item.first], + targetTokenId, autoremove); + if (tempRet == ERR_OK) { + ret = ERR_OK; + } + } + return ret; } int UriPermissionManagerStubImpl::GetUriPermissionFlag(const Uri &uri, unsigned int flag, @@ -156,7 +172,7 @@ int UriPermissionManagerStubImpl::GetUriPermissionFlag(const Uri &uri, unsigned return CHECK_PERMISSION_FAILED; } if (!authorityFlag) { - // ignore persistable uri permission flag. + // application uri: ignore persistable uri permission flag. newFlag &= (~Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION); return ERR_OK; } @@ -166,6 +182,7 @@ int UriPermissionManagerStubImpl::GetUriPermissionFlag(const Uri &uri, unsigned HILOG_WARN("Do not have persistable uri permission proxy."); return CHECK_PERMISSION_FAILED; } + // the device do not support persistable uri permission flag. newFlag &= (~Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION); return ERR_OK; } @@ -252,7 +269,13 @@ int UriPermissionManagerStubImpl::GrantUriPermissionImpl(const Uri &uri, unsigne return INNER_ERR; } auto uriStr = uri.ToString(); - auto ret = storageManager_->CreateShareFile(uriStr, targetTokenId, flag); + std::vector uriVec = { uriStr }; + auto resVec = storageManager_->CreateShareFile(uriVec, targetTokenId, flag); + if (resVec.size() == 0) { + HILOG_ERROR("storageManager resVec is empty."); + return INNER_ERR; + } + auto ret = resVec[0]; if (ret != 0 && ret != -EEXIST) { HILOG_ERROR("failed to CreateShareFile."); return INNER_ERR; @@ -271,6 +294,106 @@ int UriPermissionManagerStubImpl::GrantUriPermissionImpl(const Uri &uri, unsigne return ret; } +int UriPermissionManagerStubImpl::GrantSingleUriPermission(const Uri &uri, unsigned int flag, + const std::string &targetBundleName, int autoremove, int32_t appIndex) +{ + Uri uri_inner = uri; + auto&& scheme = uri_inner.GetScheme(); + if (scheme != "file") { + HILOG_WARN("only support file uri."); + return ERR_CODE_INVALID_URI_TYPE; + } + auto&& authority = uri_inner.GetAuthority(); + auto fromTokenId = GetTokenIdByBundleName(authority, 0); + auto targetTokenId = GetTokenIdByBundleName(targetBundleName, appIndex); + unsigned int tmpFlag = 0; + auto ret = GetUriPermissionFlag(uri, flag, fromTokenId, targetTokenId, tmpFlag); + if (ret != ERR_OK || tmpFlag == 0) { + return ret; + } + ret = GrantUriPermissionImpl(uri, tmpFlag, fromTokenId, targetTokenId, autoremove); + return ret; +} + +void UriPermissionManagerStubImpl::GetUriPermissionBatchFlag(const std::vector &uriVec, + unsigned int flag, uint32_t targetTokenId, + std::unordered_map> &uriVecMap, + std::unordered_map> &fromTokenIdVecMap) +{ + HILOG_DEBUG("GetUriPermissionBatchFlag Call, flag is %{public}i", flag); + for (const auto &uri : uriVec) { + Uri uri_inner = uri; + auto&& scheme = uri_inner.GetScheme(); + if (scheme != "file") { + HILOG_WARN("only support file uri."); + continue; + } + auto&& authority = uri_inner.GetAuthority(); + auto fromTokenId = GetTokenIdByBundleName(authority, 0); + unsigned int tmpFlag = 0; + auto ret = GetUriPermissionFlag(uri, flag, fromTokenId, targetTokenId, tmpFlag); + if (ret != ERR_OK || tmpFlag == 0) { + continue; + } + if (uriVecMap.find(tmpFlag) == uriVecMap.end()) { + HILOG_DEBUG("find tempFlag = %{public}i", tmpFlag); + std::vector uriVec; + uriVecMap.emplace(tmpFlag, uriVec); + std::vector tokenIdVec; + fromTokenIdVecMap.emplace(tmpFlag, tokenIdVec); + } + uriVecMap[tmpFlag].emplace_back(uri.ToString()); + fromTokenIdVecMap[tmpFlag].emplace_back(fromTokenId); + } +} + +int UriPermissionManagerStubImpl::GrantBatchUriPermissionImpl(const std::vector &uriVec, + unsigned int flag, std::vector &fromTokenIdVec, TokenId targetTokenId, int autoremove) +{ + HILOG_DEBUG("CALL: targetTokenId is %{public}d, flag is %{public}i, uriVec size is %{public}zu", + targetTokenId, flag, uriVec.size()); + ConnectManager(storageManager_, STORAGE_MANAGER_MANAGER_ID); + if (storageManager_ == nullptr) { + HILOG_ERROR("ConnectManager failed"); + return INNER_ERR; + } + auto resVec = storageManager_->CreateShareFile(uriVec, targetTokenId, flag); + if (resVec.size() == 0) { + HILOG_ERROR("storageManager resVec is empty."); + return INNER_ERR; + } + if (resVec.size() > 0 && resVec.size() != uriVec.size()) { + HILOG_ERROR("Failed to createShareFile."); + return resVec[0]; + } + int successCount = 0; + for (size_t i = 0; i < uriVec.size(); i++) { + auto ret = resVec[i]; + if (ret != 0 && ret != -EEXIST) { + HILOG_ERROR("failed to CreateShareFile."); + continue; + } + auto uriStr = uriVec[i]; + auto fromTokenId = fromTokenIdVec[i]; + if ((flag & Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION) == 0) { + ret = AddTempUriPermission(uriStr, flag, fromTokenId, targetTokenId, autoremove); + successCount += (ret == ERR_OK ? 1 : 0); + continue; + } + // grant persistable uri permission + ret = uriPermissionRdb_->AddGrantInfo(uriStr, flag, fromTokenId, targetTokenId); + if (ret == ERR_OK) { + successCount++; + DeletTempUriPermission(uriStr, flag, targetTokenId); + } + } + HILOG_DEBUG("total %{public}i uri permissions added.", successCount); + if (successCount == 0) { + return INNER_ERR; + } + return ERR_OK; +} + void UriPermissionManagerStubImpl::RevokeUriPermission(const TokenId tokenId) { HILOG_INFO("Start to remove uri permission."); @@ -375,8 +498,6 @@ int UriPermissionManagerStubImpl::RevokeUriPermissionManually(const Uri &uri, co auto uriTokenId = GetTokenIdByBundleName(authority, 0); auto tokenId = GetTokenIdByBundleName(bundleName, 0); auto callerTokenId = IPCSkeleton::GetCallingTokenID(); - VerifyUriPermission(uri, Want::FLAG_AUTH_READ_URI_PERMISSION, tokenId); - VerifyUriPermission(uri, Want::FLAG_AUTH_WRITE_URI_PERMISSION, tokenId); auto permission = PermissionVerification::GetInstance()->VerifyCallingPermission( AAFwk::PermissionConstants::PERMISSION_PROXY_AUTHORIZATION_URI); bool authorityFlag = authority == "media" || authority == "docs"; diff --git a/test/unittest/uri_permission_impl_test/mock/include/storage_manager_service_mock.h b/test/unittest/uri_permission_impl_test/mock/include/storage_manager_service_mock.h index 0248bf8115..d40bf29765 100755 --- a/test/unittest/uri_permission_impl_test/mock/include/storage_manager_service_mock.h +++ b/test/unittest/uri_permission_impl_test/mock/include/storage_manager_service_mock.h @@ -212,15 +212,22 @@ public: return E_OK; } - virtual int32_t CreateShareFile(std::string uri, uint32_t tokenId, uint32_t flag) override + virtual std::vector CreateShareFile(const std::vector &uriList, + uint32_t tokenId, uint32_t flag) override { - if (isZero) { - return E_OK; + int size = uriList.size(); + if (size <= 0) { + return { -1 }; } - return -1; + if (isZero) { + std::vector retVec(size, ERR_OK); + return retVec; + } + std::vector retVec(size, -1); + return retVec; } - - virtual int32_t DeleteShareFile(uint32_t tokenId, std::vectorsharePathList) override + + virtual int32_t DeleteShareFile(uint32_t tokenId, const std::vector &sharePathList) override { return E_OK; } diff --git a/test/unittest/uri_permission_persistable_test/mock/include/storage_manager_service_mock.h b/test/unittest/uri_permission_persistable_test/mock/include/storage_manager_service_mock.h index 0248bf8115..5ddd7093d1 100755 --- a/test/unittest/uri_permission_persistable_test/mock/include/storage_manager_service_mock.h +++ b/test/unittest/uri_permission_persistable_test/mock/include/storage_manager_service_mock.h @@ -212,15 +212,22 @@ public: return E_OK; } - virtual int32_t CreateShareFile(std::string uri, uint32_t tokenId, uint32_t flag) override + virtual std::vector CreateShareFile(const std::vector &uriList, uint32_t tokenId, + uint32_t flag) override { - if (isZero) { - return E_OK; + int size = uriList.size(); + if (size <= 0) { + return { -1 }; } - return -1; + if (isZero) { + std::vector retVec(size, ERR_OK); + return retVec; + } + std::vector retVec(size, -1); + return retVec; } - - virtual int32_t DeleteShareFile(uint32_t tokenId, std::vectorsharePathList) override + + virtual int32_t DeleteShareFile(uint32_t tokenId, const std::vector &sharePathList) override { return E_OK; }