From a318bc3c0d85ec258dd3cf00a1a1e2f7d2c3f2df Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Thu, 30 Nov 2023 19:13:33 +0800 Subject: [PATCH 01/14] modify Signed-off-by: LVB8189 --- interfaces/innerkits/native/BUILD.gn | 4 + .../file_share/include/file_permission.h | 76 ++ .../native/file_share/src/file_permission.cpp | 216 ++++ interfaces/kits/js/BUILD.gn | 3 + .../js/file_share/fileshare_n_exporter.cpp | 157 +++ .../kits/js/file_share/fileshare_n_exporter.h | 7 +- .../file_share/grant_multiple_permissions.cpp | 366 ++++++ .../file_share/grant_multiple_permissions.h | 42 + test/unittest/file_share_native/BUILD.gn | 2 + .../file_share_native/file_share_test.cpp | 1042 +++++++++++------ 10 files changed, 1544 insertions(+), 371 deletions(-) create mode 100644 interfaces/innerkits/native/file_share/include/file_permission.h create mode 100644 interfaces/innerkits/native/file_share/src/file_permission.cpp create mode 100644 interfaces/kits/js/file_share/grant_multiple_permissions.cpp create mode 100644 interfaces/kits/js/file_share/grant_multiple_permissions.h diff --git a/interfaces/innerkits/native/BUILD.gn b/interfaces/innerkits/native/BUILD.gn index a66a94ad7..63fe0b5e6 100644 --- a/interfaces/innerkits/native/BUILD.gn +++ b/interfaces/innerkits/native/BUILD.gn @@ -17,6 +17,7 @@ import("//foundation/filemanagement/app_file_service/app_file_service.gni") config("file_share_config") { visibility = [ ":*" ] include_dirs = [ + "file_permission/include", "file_share/include", "//third_party/json/include", "../../common/include", @@ -47,6 +48,7 @@ ohos_shared_library("fileshare_native") { "../../common/src/json_utils.cpp", "../../common/src/sandbox_helper.cpp", "file_share/src/file_share.cpp", + "file_share/src/file_permission.cpp", ] public_configs = [ ":file_share_config" ] @@ -57,7 +59,9 @@ ohos_shared_library("fileshare_native") { "ability_base:zuri", "access_token:libaccesstoken_sdk", "c_utils:utils", + "file_api:filemgmt_libn", "hilog:libhilog", + "init:libbegetutil", ] part_name = "app_file_service" diff --git a/interfaces/innerkits/native/file_share/include/file_permission.h b/interfaces/innerkits/native/file_share/include/file_permission.h new file mode 100644 index 000000000..fe41d105a --- /dev/null +++ b/interfaces/innerkits/native/file_share/include/file_permission.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef APP_FILE_SERVICE_FILE_PERMISSION +#define APP_FILE_SERVICE_FILE_PERMISSION + +#include +#include +#include + +namespace OHOS { +namespace AppFileService { +using namespace std; +typedef enum OperateMode { + READ_MODE = 1 << 0, + WRITE_MODE = 1 << 1, +} OperateMode; +typedef enum PolicyFlag { + ALLOWED_PERSIST = 1 << 0, + FORBID_PERSIST = 1 << 1, +} PolicyFlag; +enum PolicyErrorCode { + FORBIDDEN_TO_BE_PERSISTED = 1, + INVALID_MODE = 2, + INVALID_PATH = 3, +}; +struct UriPolicyInfo { + string uri = ""; + uint32_t mode = OperateMode::READ_MODE; +}; +struct PolicyInfo { + string path = ""; + uint32_t mode = OperateMode::READ_MODE; +}; +struct PolicyErrorResult { + string uri = ""; + PolicyErrorCode code = PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED; + string message = ""; +}; + +class FilePermission { +public: + static int32_t GrantPermission(uint32_t tokenId, vector uriPolicies, uint32_t policyFlag); + static int32_t PersistPermission(vector uriPolicies, deque &errorResults); + static int32_t RevokePermission(vector uriPolicies, + deque &errorResults); + static int32_t ActivatePermission(vector uriPolicies, + deque &errorResults); + static int32_t DeactivatePermission(vector uriPolicies, + deque &errorResults); + +private: + static void GetErrorResults(const vector &resultCodes, + const vector &resultUris, + deque &errorResults); + static void GetPolicyInformation(const vector &uriPolicies, + vector &resultUris, + deque &errorResults, + vector &policies); +}; +} // namespace AppFileService +} // namespace OHOS + +#endif \ No newline at end of file diff --git a/interfaces/innerkits/native/file_share/src/file_permission.cpp b/interfaces/innerkits/native/file_share/src/file_permission.cpp new file mode 100644 index 000000000..d2a11898d --- /dev/null +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "file_permission.h" +#include + +#include "filemgmt_libn.h" +#include "log.h" +#include "parameter.h" +#include "uri.h" + +namespace OHOS { +namespace AppFileService { +const std::string MEDIA_AUTHORITY = "media"; +const std::string REMOTE_SHARE_PATH_DIR = "/.remote_share"; +const std::string FORBIDDEN_TO_BE_PERSISTED_MESSAGE = "URI refusal to be persisted!"; +const std::string INVALID_MODE_MESSAGE = "Invalid operation mode!"; +const std::string INVALID_PATH_MESSAGE = "Invalid path!"; +const int32_t FULL_MOUNT_ENABLE_SIZE = 6; +const char *FULL_MOUNT_ENABLE_PARAMETER = "const.filemanager.full_mout.enable"; + +namespace { +bool CheckValidUri(const string &uriStr) +{ + Uri uri(uriStr); + std::string bundleName = uri.GetAuthority(); + if (bundleName == MEDIA_AUTHORITY) { + LOGE("the URI is media URI"); + return false; + } + if (uriStr.find(REMOTE_SHARE_PATH_DIR) != string::npos) { + LOGE("the URI is distributed URI"); + return false; + } + return true; +} + +bool CheckFileManagerFullMountEnable() +{ + char value[FULL_MOUNT_ENABLE_SIZE] = "false"; + int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, FULL_MOUNT_ENABLE_SIZE); + if (retSystem > 0 && !strcmp(value, "true")) { + LOGE("The full mount enable parameter is true"); + return true; + } + LOGD("The full mount enable parameter is false"); + return false; +} +} // namespace + +void FilePermission::GetErrorResults(const vector &resultCodes, + const vector &resultUris, + deque &errorResults) +{ + for (int i = 0; i < resultCodes.size(); i++) { + PolicyErrorResult result; + switch (resultCodes[i]) { + case static_cast(PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED): + result = {resultUris[i], PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED, FORBIDDEN_TO_BE_PERSISTED_MESSAGE}; + errorResults.emplace_back(result); + break; + case static_cast(PolicyErrorCode::INVALID_MODE): + result = {resultUris[i], PolicyErrorCode::INVALID_MODE, INVALID_MODE_MESSAGE}; + errorResults.emplace_back(result); + break; + case static_cast(PolicyErrorCode::INVALID_PATH): + result = {resultUris[i], PolicyErrorCode::INVALID_PATH, INVALID_PATH_MESSAGE}; + errorResults.emplace_back(result); + break; + default: + break; + } + } +} + +void FilePermission::GetPolicyInformation(const vector &uriPolicies, + vector &resultUris, + deque &errorResults, + vector &policies) +{ + for (auto uriPolicy : uriPolicies) { + Uri uri(uriPolicy.uri); + string path = uri.GetPath(); + if (!CheckValidUri(uriPolicy.uri) || access(path.c_str(), F_OK) != 0) { + LOGE("Not the correct uri!"); + PolicyErrorResult result = {uriPolicy.uri, PolicyErrorCode::INVALID_PATH, INVALID_PATH_MESSAGE}; + errorResults.emplace_back(result); + } else { + PolicyInfo policyInfo = {path, uriPolicy.mode}; + policies.emplace_back(policyInfo); + resultUris.emplace_back(uriPolicy.uri); + } + } +} + +int32_t FilePermission::GrantPermission(uint32_t tokenId, vector uriPolicies, uint32_t policyFlag) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + return E_DEVICENOTSUPPORT; + } + vector policies; + vector resultUris; + deque errorResults; + GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + // SandboxManager interface call + // int32_t SandboxRet = SandboxManager::GrantPermission(tokenId, resultCodes); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("GrantPermission success"); + return 0; +} + +int32_t FilePermission::PersistPermission(vector uriPolicies, + deque &errorResults) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + return E_DEVICENOTSUPPORT; + } + vector policies; + vector resultUris; + vector resultCodes; + GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + // SandboxManager interface call + // int32_t SandboxRet = SandboxManager::PersistPermission(policies, resultCodes); + GetErrorResults(resultCodes, resultUris, errorResults); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("PersistPermission success"); + return 0; +} + +int32_t FilePermission::RevokePermission(vector uriPolicies, + deque &errorResults) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + return E_DEVICENOTSUPPORT; + } + vector policies; + vector resultUris; + vector resultCodes; + GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + // SandboxManager interface call + // int32_t SandboxRet = SandboxManager::RevokePermission(policies, resultCodes); + GetErrorResults(resultCodes, resultUris, errorResults); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("RevokePermission success"); + return 0; +} + +int32_t FilePermission::ActivatePermission(vector uriPolicies, + deque &errorResults) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + return E_DEVICENOTSUPPORT; + } + vector policies; + vector resultUris; + vector resultCodes; + GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + // SandboxManager interface call + // int32_t SandboxRet = SandboxManager::ActivatePermission(policies, resultCodes); + GetErrorResults(resultCodes, resultUris, errorResults); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("ActivatePermission success"); + return 0; +} + +int32_t FilePermission::DeactivatePermission(vector uriPolicies, + deque &errorResults) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + return E_DEVICENOTSUPPORT; + } + vector policies; + vector resultUris; + vector resultCodes; + GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + // SandboxManager interface call + // int32_t SandboxRet = SandboxManager::DeactivatePermission(policies, resultCodes); + GetErrorResults(resultCodes, resultUris, errorResults); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("DeactivatePermission success"); + return 0; +} + +} // namespace AppFileService +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index 4aa1ffc53..0645315ca 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -55,11 +55,13 @@ ohos_shared_library("fileshare") { include_dirs = [ ".", "../../common/include", + "${app_file_service_path}/interfaces/innerkits/native/file_permission/include", ] sources = [ "file_share/fileshare_n_exporter.cpp", "file_share/grant_uri_permission.cpp", + "file_share/grant_multiple_permissions.cpp", ] external_deps = [ @@ -67,6 +69,7 @@ ohos_shared_library("fileshare") { "ability_base:zuri", "ability_runtime:abilitykit_native", "ability_runtime:uri_permission_mgr", + "access_token:libaccesstoken_sdk", "access_token:libtokenid_sdk", "c_utils:utils", "common_event_service:cesfwk_innerkits", diff --git a/interfaces/kits/js/file_share/fileshare_n_exporter.cpp b/interfaces/kits/js/file_share/fileshare_n_exporter.cpp index a293e3057..8df0f1dcb 100644 --- a/interfaces/kits/js/file_share/fileshare_n_exporter.cpp +++ b/interfaces/kits/js/file_share/fileshare_n_exporter.cpp @@ -14,6 +14,7 @@ */ #include "fileshare_n_exporter.h" #include "grant_uri_permission.h" +#include "grant_multiple_permissions.h" namespace OHOS { namespace AppFileService { @@ -23,13 +24,169 @@ namespace ModuleFileShare { ***********************************************/ napi_value FileShareExport(napi_env env, napi_value exports) { + InitOperateMode(env, exports); + InitPolicyFlag(env, exports); + InitPolicyInfo(env, exports); + InitPolicyErrorCode(env, exports); + InitPolicyErrorResult(env, exports); static napi_property_descriptor desc[] = { DECLARE_NAPI_FUNCTION("grantUriPermission", GrantUriPermission::Async), + DECLARE_NAPI_FUNCTION("grantPermission", GrantPermission), + DECLARE_NAPI_FUNCTION("persistPermission", PersistPermission), + DECLARE_NAPI_FUNCTION("revokePermission", RevokePermission), + DECLARE_NAPI_FUNCTION("activatePermission", ActivatePermission), + DECLARE_NAPI_FUNCTION("deactivatePermission", DeactivatePermission), }; napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc); return exports; } + +static napi_value InitPolicyConstructor(napi_env env, napi_callback_info info) +{ + size_t argc = 0; + napi_value args[1] = {0}; + napi_value res = nullptr; + void *data = nullptr; + napi_status status = napi_get_cb_info(env, info, &argc, args, &res, &data); + if (status != napi_ok) { + HILOGE("InitPolicyConstructor, status is not napi_ok"); + return nullptr; + } + return res; +} + +void InitOperateMode(napi_env env, napi_value exports) +{ + char propertyName[] = "OperateMode"; + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("READ_MODE", + NVal::CreateUint32(env, static_cast(OperateMode::READ_MODE)).val_), + DECLARE_NAPI_STATIC_PROPERTY("WRITE_MODE", + NVal::CreateUint32(env, static_cast(OperateMode::WRITE_MODE)).val_), + }; + napi_value obj = nullptr; + napi_status status = napi_create_object(env, &obj); + if (status != napi_ok) { + HILOGE("Failed to create object at initializing OperateMode"); + return; + } + status = napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc); + if (status != napi_ok) { + HILOGE("Failed to set properties of character at initializing OperateMode"); + return; + } + status = napi_set_named_property(env, exports, propertyName, obj); + if (status != napi_ok) { + HILOGE("Failed to set direction property at initializing OperateMode"); + return; + } +} + +void InitPolicyFlag(napi_env env, napi_value exports) +{ + char propertyName[] = "PolicyFlag"; + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("ALLOWED_PERSIST", + NVal::CreateUint32(env, static_cast(PolicyFlag::ALLOWED_PERSIST)).val_), + DECLARE_NAPI_STATIC_PROPERTY("FORBID_PERSIST", + NVal::CreateUint32(env, static_cast(PolicyFlag::FORBID_PERSIST)).val_), + }; + napi_value obj = nullptr; + napi_status status = napi_create_object(env, &obj); + if (status != napi_ok) { + HILOGE("Failed to create object at initializing PolicyFlag"); + return; + } + status = napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc); + if (status != napi_ok) { + HILOGE("Failed to set properties of character at initializing PolicyFlag"); + return; + } + status = napi_set_named_property(env, exports, propertyName, obj); + if (status != napi_ok) { + HILOGE("Failed to set direction property at initializing PolicyFlag"); + return; + } +} + +void InitPolicyErrorCode(napi_env env, napi_value exports) +{ + char propertyName[] = "PolicyErrorCode"; + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY( + "FORBIDDEN_TO_BE_PERSISTED", + NVal::CreateInt32(env, static_cast(PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED)).val_), + DECLARE_NAPI_STATIC_PROPERTY("INVALID_MODE", + NVal::CreateInt32(env, static_cast(PolicyErrorCode::INVALID_MODE)).val_), + DECLARE_NAPI_STATIC_PROPERTY("INVALID_PATH", + NVal::CreateInt32(env, static_cast(PolicyErrorCode::INVALID_PATH)).val_), + }; + napi_value obj = nullptr; + napi_status status = napi_create_object(env, &obj); + if (status != napi_ok) { + HILOGE("Failed to create object at initializing InitPolicyErrorCode"); + return; + } + status = napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc); + if (status != napi_ok) { + HILOGE("Failed to set properties of character at initializing InitPolicyErrorCode"); + return; + } + status = napi_set_named_property(env, exports, propertyName, obj); + if (status != napi_ok) { + HILOGE("Failed to set direction property at initializing InitPolicyErrorCode"); + return; + } +} + +void InitPolicyErrorResult(napi_env env, napi_value exports) +{ + char className[] = "PolicyErrorResult"; + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("uri", NVal::CreateUTF8String(env, "uri").val_), + DECLARE_NAPI_STATIC_PROPERTY( + "code", NVal::CreateInt32(env, static_cast(PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED)).val_), + DECLARE_NAPI_STATIC_PROPERTY("message", NVal::CreateUTF8String(env, "message").val_), + }; + napi_value obj = nullptr; + napi_status status = napi_define_class(env, className, NAPI_AUTO_LENGTH, InitPolicyConstructor, nullptr, + sizeof(desc) / sizeof(desc[0]), desc, &obj); + napi_create_object(env, &obj); + if (status != napi_ok) { + HILOGE("Failed to define class at initializing PolicyErrorResult"); + return; + } + status = napi_set_named_property(env, exports, className, obj); + if (status != napi_ok) { + HILOGE("Failed to set direction property at initializing PolicyErrorResult"); + return; + } +} + +void InitPolicyInfo(napi_env env, napi_value exports) +{ + char className[] = "PolicyInfo"; + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("uri", NVal::CreateUTF8String(env, "uri").val_), + DECLARE_NAPI_STATIC_PROPERTY("operaMode", + NVal::CreateUint32(env, static_cast(OperateMode::READ_MODE)).val_), + }; + napi_value obj = nullptr; + napi_status status = napi_define_class(env, className, NAPI_AUTO_LENGTH, InitPolicyConstructor, nullptr, + sizeof(desc) / sizeof(desc[0]), desc, &obj); + napi_create_object(env, &obj); + if (status != napi_ok) { + HILOGE("Failed to define class at initializing PolicyFlag"); + return; + } + status = napi_set_named_property(env, exports, className, obj); + if (status != napi_ok) { + HILOGE("Failed to set direction property at initializing PolicyFlag"); + return; + } +} + NAPI_MODULE(fileshare, FileShareExport) } // namespace ModuleFileShare } // namespace AppFileService diff --git a/interfaces/kits/js/file_share/fileshare_n_exporter.h b/interfaces/kits/js/file_share/fileshare_n_exporter.h index 556f62a8a..e1490f84a 100644 --- a/interfaces/kits/js/file_share/fileshare_n_exporter.h +++ b/interfaces/kits/js/file_share/fileshare_n_exporter.h @@ -20,7 +20,12 @@ namespace OHOS { namespace AppFileService { namespace ModuleFileShare { - napi_value FileShareExport(napi_env env, napi_value exports); +void InitOperateMode(napi_env env, napi_value exports); +void InitPolicyFlag(napi_env env, napi_value exports); +void InitPolicyInfo(napi_env env, napi_value exports); +void InitPolicyErrorResult(napi_env env, napi_value exports); +void InitPolicyErrorCode(napi_env env, napi_value exports); +napi_value FileShareExport(napi_env env, napi_value exports); } // namespace ModuleFileShare } // namespace AppFileService } // namespace OHOS diff --git a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp new file mode 100644 index 000000000..0441bed17 --- /dev/null +++ b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp @@ -0,0 +1,366 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "grant_multiple_permissions.h" + +#include +#include + +#include "access_token.h" +#include "accesstoken_kit.h" +#include "ipc_skeleton.h" +#include "log.h" +#include "tokenid_kit.h" +#include "n_napi.h" + + +namespace OHOS { +namespace AppFileService { +namespace ModuleFileShare { +using namespace OHOS::FileManagement::LibN; +using namespace std; + +const std::string FILE_ACCESS_PERMISSION = "ohos.permission.FILE_ACCESS_PERSIST"; +const std::string SET_SANDBOX_POLICY_PERMISSION = "ohos.permission.SET_SANDBOX_POLICY"; + +namespace { +bool IsSystemApp() +{ + uint32_t fullTokenId = OHOS::IPCSkeleton::GetCallingFullTokenID(); + return Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(fullTokenId); +} + +bool CheckPermission(const string &permission) +{ + Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID(); + return Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission) == + Security::AccessToken::PermissionState::PERMISSION_GRANTED; +} +} // namespace + +static napi_value GetErrData(napi_env env, deque &errorResults) +{ + napi_value res = nullptr; + napi_status status = napi_create_array(env, &res); + if (status != napi_ok) { + LOGE("Failed to create array"); + return nullptr; + } + size_t index = 0; + for (auto &iter : errorResults) { + NVal obj = NVal::CreateObject(env); + obj.AddProp("uri", NVal::CreateUTF8String(env, iter.uri).val_); + obj.AddProp("code", NVal::CreateInt32(env, iter.code).val_); + obj.AddProp("message", NVal::CreateUTF8String(env, iter.message).val_); + status = napi_set_element(env, res, index++, obj.val_); + if (status != napi_ok) { + LOGE("Failed to set element on data"); + return nullptr; + } + } + return res; +} + +static napi_status GetUriPoliciesArg(napi_env env, napi_value agrv, std::vector &uriPolicies){ + uint32_t count; + napi_status status = napi_get_array_length(env, agrv, &count); + if (status != napi_ok) { + LOGE("get array length failed"); + return status; + } + for (uint32_t i = 0; i < count; i++) { + napi_handle_scope scope; + status = napi_open_handle_scope(env, &scope); + if (status != napi_ok) { + return status; + } + napi_value object; + status = napi_get_element(env, agrv, i, &object); + if (status != napi_ok) { + LOGE("get element failed"); + return status; + } + UriPolicyInfo uriPolicy; + napi_value uriValue; + napi_value modeValue; + status = napi_get_named_property(env, object, "uri", &uriValue); + if (status != napi_ok) { + LOGE("get named property failed"); + return status; + } + status = napi_get_named_property(env, object, "operateMode", &modeValue); + if (status != napi_ok) { + LOGE("get named property failed"); + return status; + } + auto [succStr, str, ignore] = NVal(env, uriValue).ToUTF8String(); + auto [succMode, mode] = NVal(env, modeValue).ToUint32(); + if(!succStr || !succMode){ + LOGE("the argument error"); + return napi_invalid_arg; + } + uriPolicy.uri = str.get(); + uriPolicy.mode = mode; + uriPolicies.emplace_back(uriPolicy); + status = napi_close_handle_scope(env, scope); + if (status != napi_ok) { + return status; + } + } + return napi_ok; +} + +napi_value GrantPermission(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::THREE)) { + LOGE("GrantPermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + if (!IsSystemApp()) { + LOGE("GrantPermission is not System App!"); + NError(E_PERMISSION_SYS).ThrowErr(env); + return nullptr; + } + if (!CheckPermission(SET_SANDBOX_POLICY_PERMISSION)) { + LOGE("GrantPermission has not ohos permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } + auto [succTokenId, id] = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32(); + auto [succPolicyFlag, flag] = NVal(env, funcArg[NARG_POS::THIRD]).ToUint32(); + if (!succTokenId || !succPolicyFlag) { + LOGE("The first/third argument error"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + int32_t tokenId = id; + uint32_t policyFlag = flag; + std::vector uriPolicies; + napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::SECOND], uriPolicies); + if(status != napi_ok){ + LOGE("the second argument error"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + auto cbExec = [tokenId, uriPolicies, policyFlag]() -> NError { + int32_t ret = FilePermission::GrantPermission(tokenId, uriPolicies, policyFlag); + return NError(ret); + }; + auto cbCompl = [](napi_env env, NError err) -> NVal { + if (err) { + return {env, err.GetNapiErr(env)}; + } + return NVal::CreateUndefined(env); + }; + + const string procedureName = "grant_permission"; + NVal thisVar(env, funcArg.GetThisVar()); + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_; +} + +napi_value PersistPermission(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + LOGE("PersistPermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + if (!CheckPermission(FILE_ACCESS_PERMISSION)) { + LOGE("PersistPermission has not ohos permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } + std::vector uriPolicies; + napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); + if(status != napi_ok){ + LOGE("get arguments failed"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Failed to request heap memory."); + NError(EILSEQ).ThrowErr(env); + return nullptr; + } + auto cbExec = [uriPolicies, arg]() -> NError { + arg->errNo = FilePermission::PersistPermission(uriPolicies, arg->errorResults); + return NError(arg->errNo); + }; + auto cbCompl = [arg](napi_env env, NError err) -> NVal { + if (err) { + if(arg->errNo == EPERM){ + napi_value data = err.GetNapiErr(env); + napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), + GetErrData(env, arg->errorResults)); + if (status != napi_ok) { + LOGE("Failed to set data property on Error"); + } + return { env, data }; + } + return {env, err.GetNapiErr(env)}; + } + return NVal::CreateUndefined(env); + }; + const string procedureName = "persist_permission"; + NVal thisVar(env, funcArg.GetThisVar()); + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_; +} + +napi_value RevokePermission(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + LOGE("RevokePermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + if (!CheckPermission(FILE_ACCESS_PERMISSION)) { + LOGE("RevokePermission has not ohos permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } + std::vector uriPolicies; + napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); + if(status != napi_ok){ + LOGE("get arguments failed"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Failed to request heap memory."); + NError(EILSEQ).ThrowErr(env); + return nullptr; + } + auto cbExec = [uriPolicies, arg]() -> NError { + arg->errNo = FilePermission::RevokePermission(uriPolicies, arg->errorResults); + return NError(arg->errNo); + }; + auto cbCompl = [arg](napi_env env, NError err) -> NVal { + if (err) { + if(arg->errNo == EPERM){ + napi_value data = err.GetNapiErr(env); + napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), + GetErrData(env, arg->errorResults)); + if (status != napi_ok) { + LOGE("Failed to set data property on Error"); + } + return { env, data }; + } + return {env, err.GetNapiErr(env)}; + } + return NVal::CreateUndefined(env); + }; + const string procedureName = "revoke_permission"; + NVal thisVar(env, funcArg.GetThisVar()); + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_; +} + +napi_value ActivatePermission(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + LOGE("ActivatePermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::vector uriPolicies; + napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); + if(status != napi_ok){ + LOGE("get arguments failed"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Failed to request heap memory."); + NError(EILSEQ).ThrowErr(env); + return nullptr; + } + auto cbExec = [uriPolicies, arg]() -> NError { + arg->errNo = FilePermission::ActivatePermission(uriPolicies, arg->errorResults); + return NError(arg->errNo); + }; + auto cbCompl = [arg](napi_env env, NError err) -> NVal { + if (err) { + if(arg->errNo == EPERM){ + napi_value data = err.GetNapiErr(env); + napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), + GetErrData(env, arg->errorResults)); + if (status != napi_ok) { + LOGE("Failed to set data property on Error"); + } + return { env, data }; + } + return {env, err.GetNapiErr(env)}; + } + return NVal::CreateUndefined(env); + }; + const string procedureName = "activate_permission"; + NVal thisVar(env, funcArg.GetThisVar()); + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_; +} + +napi_value DeactivatePermission(napi_env env, napi_callback_info info) +{ + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + LOGE("DeactivatePermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::vector uriPolicies; + napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); + if(status != napi_ok){ + LOGE("get arguments failed"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + LOGE("DeactivatePermission %{public}d", uriPolicies.size()); + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Failed to request heap memory."); + NError(EILSEQ).ThrowErr(env); + return nullptr; + } + auto cbExec = [uriPolicies, arg]() -> NError { + arg->errNo = FilePermission::DeactivatePermission(uriPolicies, arg->errorResults); + return NError(arg->errNo); + }; + auto cbCompl = [arg](napi_env env, NError err) -> NVal { + if (err) { + if(arg->errNo == EPERM){ + napi_value data = err.GetNapiErr(env); + napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), + GetErrData(env, arg->errorResults)); + if (status != napi_ok) { + LOGE("Failed to set data property on Error"); + } + return { env, data }; + } + return {env, err.GetNapiErr(env)}; + } + return NVal::CreateUndefined(env); + }; + const string procedureName = "deactivate_permission"; + NVal thisVar(env, funcArg.GetThisVar()); + return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_; +} +} // namespace ModuleFileShare +} // namespace AppFileService +} // namespace OHOS diff --git a/interfaces/kits/js/file_share/grant_multiple_permissions.h b/interfaces/kits/js/file_share/grant_multiple_permissions.h new file mode 100644 index 000000000..1498f7fea --- /dev/null +++ b/interfaces/kits/js/file_share/grant_multiple_permissions.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef GRANT_MULTIPLE_PERMISSIONS_H + +#define GRANT_MULTIPLE_PERMISSIONS_H + +#include + +#include "file_permission.h" +#include "filemgmt_libn.h" + +namespace OHOS { +namespace AppFileService { +namespace ModuleFileShare { +napi_value GrantPermission(napi_env env, napi_callback_info info); +napi_value PersistPermission(napi_env env, napi_callback_info info); +napi_value RevokePermission(napi_env env, napi_callback_info info); +napi_value ActivatePermission(napi_env env, napi_callback_info info); +napi_value DeactivatePermission(napi_env env, napi_callback_info info); + +struct PolicyErrorArgs { + deque errorResults; + int32_t errNo = 0; + ~PolicyErrorArgs() = default; +}; +} // namespace ModuleFileShare +} // namespace AppFileService +} // namespace OHOS +#endif // GRANT_MULTIPLE_PERMISSIONS_H diff --git a/test/unittest/file_share_native/BUILD.gn b/test/unittest/file_share_native/BUILD.gn index 17dd4d7a4..e03c69119 100644 --- a/test/unittest/file_share_native/BUILD.gn +++ b/test/unittest/file_share_native/BUILD.gn @@ -25,7 +25,9 @@ ohos_unittest("file_share_test") { "access_token:libaccesstoken_sdk", "app_file_service:fileshare_native", "c_utils:utils", + "file_api:filemgmt_libn", "hilog:libhilog", + "init:libbegetutil", "ipc:ipc_core", ] } diff --git a/test/unittest/file_share_native/file_share_test.cpp b/test/unittest/file_share_native/file_share_test.cpp index 9b2ac0c6f..7b44c6cec 100644 --- a/test/unittest/file_share_native/file_share_test.cpp +++ b/test/unittest/file_share_native/file_share_test.cpp @@ -15,7 +15,9 @@ #include #include +#include #include + #include #include #include @@ -24,389 +26,689 @@ #include "access_token_error.h" #include "accesstoken_kit.h" +#include "file_permission.h" #include "file_share.h" +#include "filemgmt_libn.h" #include "ipc_skeleton.h" +#include "log.h" +#include "parameter.h" #include "sandbox_helper.h" +#include "uri.h" namespace { - using namespace std; - using namespace OHOS::AppFileService; - using namespace OHOS::Security::AccessToken; - - const int E_OK = 0; - - class FileShareTest : public testing::Test { - public: - static void SetUpTestCase(void) {}; - static void TearDownTestCase() {}; - void SetUp() {}; - void TearDown() {}; - }; - - /** - * @tc.name: file_share_test_0000 - * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_CreateShareFile_0000, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0000"; - - int32_t uid = 100; - - string bundleNameA = "com.example.filesharea"; - string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; - int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); - ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; - close(fd); - string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; - - string bundleNameB = "com.example.fileshareb"; - uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); - - int32_t flag = 3; - vector uriList(1, uri); - vector retList; - int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); - EXPECT_EQ(ret, E_OK); - - uriList.clear(); - retList.clear(); - uri.clear(); - uri = "file://" + bundleNameA + "/data/storage/el2/base/files/../files/test.txt"; - uriList.push_back(uri); - ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0000"; - } - - /** - * @tc.name: file_share_test_0001 - * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_CreateShareFile_0001, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0001"; - - int32_t uid = 100; - - string bundleNameA = "com.example.filesharea"; - string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; - int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); - ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; - close(fd); - string uri = "file://" + bundleNameA + "/data/test/el2/base/files/test.txt"; - - string bundleNameB = "com.example.fileshareb"; - uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); - - int32_t flag = 3; - vector uriList(1, uri); - vector retList; - int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0001"; +using namespace std; +using namespace OHOS::AppFileService; +using namespace OHOS::Security::AccessToken; + +const int E_OK = 0; +const string bundleA = "com.example.filesharea"; + +class FileShareTest : public testing::Test { +public: + static void SetUpTestCase(void) {}; + static void TearDownTestCase() {}; + void SetUp() {}; + void TearDown() {}; +}; +bool CheckFileManagerFullMountEnable() +{ + char value[FULL_MOUNT_ENABLE_SIZE] = "false"; + int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, FULL_MOUNT_ENABLE_SIZE); + if (retSystem > 0 && !strcmp(value, "true")) { + return true; } - - /** - * @tc.name: file_share_test_0002 - * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_CreateShareFile_0002, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0002"; - int32_t uid = 100; - - string bundleNameA = "com.example.filesharea"; - string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; - int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); - ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; - close(fd); - string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; - uint32_t tokenId = 100; - - int32_t flag = 3; - vector uriList(1, uri); - vector retList; - int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); - EXPECT_EQ(ret, static_cast(AccessTokenError::ERR_TOKENID_NOT_EXIST)); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0002"; - } - - /** - * @tc.name: file_share_test_0003 - * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_CreateShareFile_0003, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0003"; - int32_t uid = 100; - - string bundleNameA = "com.example.filesharea"; - string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; - int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); - ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; - close(fd); - string uri = ""; - - string bundleNameB = "com.example.fileshareb"; - uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); - - int32_t flag = 3; - vector uriList(1, uri); - vector retList; - int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0003"; - } - - /** - * @tc.name: file_share_test_0004 - * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_CreateShareFile_0004, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0004"; - int32_t uid = 100; - - string bundleNameA = "com.example.filesharea"; - string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; - int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); - ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; - close(fd); - string uri = ""; - - string bundleNameB = "com.example.fileshareb"; - uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); - - int32_t flag = 4; - vector uriList(1, uri); - vector retList; - int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0004"; + return false; +} + +/** + * @tc.name: file_share_test_0000 + * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_CreateShareFile_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0000"; + + int32_t uid = 100; + + string bundleNameA = "com.example.filesharea"; + string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; + int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); + ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; + close(fd); + string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; + + string bundleNameB = "com.example.fileshareb"; + uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); + + int32_t flag = 3; + vector uriList(1, uri); + vector retList; + int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); + EXPECT_EQ(ret, E_OK); + + uriList.clear(); + retList.clear(); + uri.clear(); + uri = "file://" + bundleNameA + "/data/storage/el2/base/files/../files/test.txt"; + uriList.push_back(uri); + ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0000"; +} + +/** + * @tc.name: file_share_test_0001 + * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_CreateShareFile_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0001"; + + int32_t uid = 100; + + string bundleNameA = "com.example.filesharea"; + string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; + int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); + ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; + close(fd); + string uri = "file://" + bundleNameA + "/data/test/el2/base/files/test.txt"; + + string bundleNameB = "com.example.fileshareb"; + uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); + + int32_t flag = 3; + vector uriList(1, uri); + vector retList; + int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0001"; +} + +/** + * @tc.name: file_share_test_0002 + * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_CreateShareFile_0002, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0002"; + int32_t uid = 100; + + string bundleNameA = "com.example.filesharea"; + string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; + int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); + ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; + close(fd); + string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; + uint32_t tokenId = 100; + + int32_t flag = 3; + vector uriList(1, uri); + vector retList; + int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); + EXPECT_EQ(ret, static_cast(AccessTokenError::ERR_TOKENID_NOT_EXIST)); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0002"; +} + +/** + * @tc.name: file_share_test_0003 + * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_CreateShareFile_0003, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0003"; + int32_t uid = 100; + + string bundleNameA = "com.example.filesharea"; + string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; + int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); + ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; + close(fd); + string uri = ""; + + string bundleNameB = "com.example.fileshareb"; + uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); + + int32_t flag = 3; + vector uriList(1, uri); + vector retList; + int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0003"; +} + +/** + * @tc.name: file_share_test_0004 + * @tc.desc: Test function of CreateShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_CreateShareFile_0004, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_CreateShareFile_0004"; + int32_t uid = 100; + + string bundleNameA = "com.example.filesharea"; + string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; + int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); + ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; + close(fd); + string uri = ""; + + string bundleNameB = "com.example.fileshareb"; + uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); + + int32_t flag = 4; + vector uriList(1, uri); + vector retList; + int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_CreateShareFile_0004"; +} + +/** + * @tc.name: file_share_test_0005 + * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_DeleteShareFile_0005, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0005"; + int32_t uid = 100; + + string bundleNameB = "com.example.fileshareb"; + uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); + vector sharePathList; + string bundleNameA = "com.example.filesharea"; + string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; + sharePathList.push_back(uri); + int32_t ret = FileShare::DeleteShareFile(tokenId, sharePathList); + EXPECT_EQ(ret, E_OK); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0005"; +} + +/** + * @tc.name: file_share_test_0006 + * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_DeleteShareFile_0006, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0006"; + uint32_t tokenId = 104; + vector sharePathList; + string bundleNameA = "com.example.filesharea"; + string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; + sharePathList.push_back(uri); + int32_t ret = FileShare::DeleteShareFile(tokenId, sharePathList); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0006"; +} + +/** + * @tc.name: File_share_DeleteShareFile_0007 + * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: SR000H63TL + */ +HWTEST_F(FileShareTest, File_share_DeleteShareFile_0007, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0007"; + int32_t uid = 100; + + string bundleNameA = "com.example.filesharea"; + string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; + int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); + ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; + close(fd); + string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; + + string bundleNameB = "com.example.fileshareb"; + uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); + + int32_t flag = 3; + vector uriList(1, uri); + vector retList; + int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); + EXPECT_EQ(ret, E_OK); + + vector sharePathList; + string uriErr = "file://" + bundleNameA + "/data/storage/el2/base/files/abc/../test.txt"; + sharePathList.push_back(uriErr); + ret = FileShare::DeleteShareFile(tokenId, sharePathList); + EXPECT_EQ(ret, E_OK); + + string sharePath = "/data/service/el2/" + to_string(uid) + "/share/" + bundleNameB + "/rw/" + bundleNameA + + "/data/storage/el2/base/files/test.txt"; + ret = access(sharePath.c_str(), F_OK); + EXPECT_EQ(ret, E_OK); + + sharePathList.push_back(uri); + ret = FileShare::DeleteShareFile(tokenId, sharePathList); + EXPECT_EQ(ret, E_OK); + + ret = access(sharePath.c_str(), F_OK); + EXPECT_EQ(ret, -1); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0007"; +} + +/** + * @tc.name: File_share_GetPhysicalPath_0001 + * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7PDZL + */ +HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0001"; + std::string fileUri = "file://media/Photo/12/IMG_12345_0011/test.jpg"; + std::string physicalPath; + int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); + EXPECT_EQ(ret, E_OK); + EXPECT_EQ(physicalPath, "/mnt/hmdfs/100/account/cloud_merge_view/files/Photo/11/IMG_12345_0011.jpg"); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0001"; +} + +/** + * @tc.name: File_share_GetPhysicalPath_0002 + * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7PDZL + */ +HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0002, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0002"; + std::string fileUri = "file://media/Photo/12/IMG_12345_/test.jpg"; + std::string physicalPath; + int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0002"; +} + +/** + * @tc.name: File_share_GetPhysicalPath_0003 + * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7PDZL + */ +HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0003, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0003"; + std::string fileUri = "file://media/Photo/12/IMG_12345_a0011/test.jpg"; + std::string physicalPath; + int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0003"; +} + +/** + * @tc.name: File_share_GetPhysicalPath_0004 + * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7PDZL + */ +HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0004, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0004"; + std::string fileUri = "file://media/Photo/IMG_12345_999999/test.jpg"; + std::string physicalPath; + int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0004"; +} + +/** + * @tc.name: File_share_GetPhysicalPath_0005 + * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7PDZL + */ +HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0005, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0005"; + std::string fileUri = "file://media/Photo/12/IMG_12345_999999/test.jpg"; + std::string physicalPath; + int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); + EXPECT_EQ(ret, E_OK); + EXPECT_EQ(physicalPath, "/mnt/hmdfs/100/account/cloud_merge_view/files/Photo/575/IMG_12345_999999.jpg"); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0005"; +} + +/** + * @tc.name: File_share_GetPhysicalPath_0006 + * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7PDZL + */ +HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0006, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0006"; + std::string fileUri = "file://media/Photo/12/IMG_12345_999999/test.jpg/other"; + std::string physicalPath; + int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); + EXPECT_EQ(ret, -EINVAL); + GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0006"; +} + +/** + * @tc.name: GrantPermission_test_0000 + * @tc.desc: Test function of GrantPermission() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, GrantPermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin GrantPermission"; + int32_t targetCode = 0; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: file_share_test_0005 - * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_DeleteShareFile_0005, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0005"; - int32_t uid = 100; - - string bundleNameB = "com.example.fileshareb"; - uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); - vector sharePathList; - string bundleNameA = "com.example.filesharea"; - string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; - sharePathList.push_back(uri); - int32_t ret = FileShare::DeleteShareFile(tokenId, sharePathList); - EXPECT_EQ(ret, E_OK); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0005"; + string uri = "file://" + bundleA + "/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::GrantPermission(tokenId, uriPolicies, policyFlag); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end GrantPermission"; +} + +/** + * @tc.name: GrantPermission_test_0001 + * @tc.desc: Test function of GrantPermission() interface for error URI. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, GrantPermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin GrantPermission_test_0001"; + int32_t targetCode = EPERM; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: file_share_test_0006 - * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_DeleteShareFile_0006, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0006"; - uint32_t tokenId = 104; - vector sharePathList; - string bundleNameA = "com.example.filesharea"; - string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; - sharePathList.push_back(uri); - int32_t ret = FileShare::DeleteShareFile(tokenId, sharePathList); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0006"; + string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string mediaUri = "file://media/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = inexistentUri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::GrantPermission(tokenId, uriPolicies, policyFlag); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end GrantPermission_test_0001"; +} + +/** + * @tc.name: PersistPermission_test_0000 + * @tc.desc: Test function of PersistPermission() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, PersistPermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin PersistPermission_test_0000"; + int32_t targetCode = 0; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: File_share_DeleteShareFile_0007 - * @tc.desc: Test function of DeleteShareFile() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: SR000H63TL - */ - HWTEST_F(FileShareTest, File_share_DeleteShareFile_0007, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_DeleteShareFile_0007"; - int32_t uid = 100; - - string bundleNameA = "com.example.filesharea"; - string fileStr = "/data/app/el2/" + to_string(uid) + "/base/" + bundleNameA + "/files/test.txt"; - int32_t fd = open(fileStr.c_str(), O_RDWR | O_CREAT); - ASSERT_TRUE(fd != -1) << "FileShareTest Create File Failed!"; - close(fd); - string uri = "file://" + bundleNameA + "/data/storage/el2/base/files/test.txt"; - - string bundleNameB = "com.example.fileshareb"; - uint32_t tokenId = AccessTokenKit::GetHapTokenID(uid, bundleNameB, 0); - - int32_t flag = 3; - vector uriList(1, uri); - vector retList; - int32_t ret = FileShare::CreateShareFile(uriList, tokenId, flag, retList); - EXPECT_EQ(ret, E_OK); - - vector sharePathList; - string uriErr = "file://" + bundleNameA + "/data/storage/el2/base/files/abc/../test.txt"; - sharePathList.push_back(uriErr); - ret = FileShare::DeleteShareFile(tokenId, sharePathList); - EXPECT_EQ(ret, E_OK); - - string sharePath = "/data/service/el2/" + to_string(uid) + "/share/" + bundleNameB + - "/rw/" + bundleNameA + "/data/storage/el2/base/files/test.txt"; - ret = access(sharePath.c_str(), F_OK); - EXPECT_EQ(ret, E_OK); - - sharePathList.push_back(uri); - ret = FileShare::DeleteShareFile(tokenId, sharePathList); - EXPECT_EQ(ret, E_OK); - - ret = access(sharePath.c_str(), F_OK); - EXPECT_EQ(ret, -1); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_DeleteShareFile_0007"; + string uri = "file://" + bundleA + "/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::PersistPermission(uriPolicies); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end PersistPermission_test_0000"; +} + +/** + * @tc.name: PersistPermission_test_0001 + * @tc.desc: Test function of PersistPermission() interface for error URI. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, PersistPermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin PersistPermission_test_0001"; + int32_t targetCode = EPERM; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: File_share_GetPhysicalPath_0001 - * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I7PDZL - */ - HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0001, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0001"; - std::string fileUri = "file://media/Photo/12/IMG_12345_0011/test.jpg"; - std::string physicalPath; - int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(physicalPath, "/mnt/hmdfs/100/account/cloud_merge_view/files/Photo/11/IMG_12345_0011.jpg"); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0001"; + string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string mediaUri = "file://media/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = inexistentUri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::PersistPermission(tokenId, uriPolicies, policyFlag); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end PersistPermission_test_0001"; +} + +/** + * @tc.name: DesistPersistedPermission_test_0000 + * @tc.desc: Test function of RevokePermission() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, DesistPersistedPermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin DesistPersistedPermission_test_0000"; + int32_t targetCode = 0; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: File_share_GetPhysicalPath_0002 - * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I7PDZL - */ - HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0002, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0002"; - std::string fileUri = "file://media/Photo/12/IMG_12345_/test.jpg"; - std::string physicalPath; - int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0002"; + string uri = "file://" + bundleA + "/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::RevokePermission(uriPolicies); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end DesistPersistedPermission_test_0000"; +} + +/** + * @tc.name: DesistPersistedPermission_test_0001 + * @tc.desc: Test function of RevokePermission() interface for error URI. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, DesistPersistedPermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin DesistPersistedPermission_test_0001"; + int32_t targetCode = EPERM; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: File_share_GetPhysicalPath_0003 - * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I7PDZL - */ - HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0003, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0003"; - std::string fileUri = "file://media/Photo/12/IMG_12345_a0011/test.jpg"; - std::string physicalPath; - int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0003"; + string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string mediaUri = "file://media/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = inexistentUri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::RevokePermission(tokenId, uriPolicies, policyFlag); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end DesistPersistedPermission_test_0001"; +} + +/** + * @tc.name: ActivatePermission_test_0000 + * @tc.desc: Test function of ActivatePermission() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin ActivatePermission_test_0000"; + int32_t targetCode = 0; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: File_share_GetPhysicalPath_0004 - * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I7PDZL - */ - HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0004, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0004"; - std::string fileUri = "file://media/Photo/IMG_12345_999999/test.jpg"; - std::string physicalPath; - int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0004"; + string uri = "file://" + bundleA + "/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::ActivatePermission(uriPolicies); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end ActivatePermission_test_0000"; +} + +/** + * @tc.name: ActivatePermission_test_0001 + * @tc.desc: Test function of ActivatePermission() interface for error URI. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, ActivatePermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin ActivatePermission_test_0001"; + int32_t targetCode = EPERM; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: File_share_GetPhysicalPath_0005 - * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I7PDZL - */ - HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0005, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0005"; - std::string fileUri = "file://media/Photo/12/IMG_12345_999999/test.jpg"; - std::string physicalPath; - int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); - EXPECT_EQ(ret, E_OK); - EXPECT_EQ(physicalPath, "/mnt/hmdfs/100/account/cloud_merge_view/files/Photo/575/IMG_12345_999999.jpg"); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0005"; + string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string mediaUri = "file://media/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = inexistentUri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::ActivatePermission(tokenId, uriPolicies, policyFlag); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end ActivatePermission_test_0001"; +} + +/** + * @tc.name: DeactivatePermission_test_0000 + * @tc.desc: Test function of DeactivatePermission() interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin DeactivatePermission_test_0000"; + int32_t targetCode = 0; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } - - /** - * @tc.name: File_share_GetPhysicalPath_0006 - * @tc.desc: Test function of GetPhysicalPath() interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I7PDZL - */ - HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0006, testing::ext::TestSize.Level1) - { - GTEST_LOG_(INFO) << "FileShareTest-begin File_share_GetPhysicalPath_0006"; - std::string fileUri = "file://media/Photo/12/IMG_12345_999999/test.jpg/other"; - std::string physicalPath; - int32_t ret = SandboxHelper::GetPhysicalPath(fileUri, "100", physicalPath); - EXPECT_EQ(ret, -EINVAL); - GTEST_LOG_(INFO) << "FileShareTest-end File_share_GetPhysicalPath_0006"; + string uri = "file://" + bundleA + "/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::DeactivatePermission(uriPolicies); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end DeactivatePermission_test_0000"; +} + +/** + * @tc.name: DeactivatePermission_test_0001 + * @tc.desc: Test function of DeactivatePermission() interface for error URI. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: + */ +HWTEST_F(FilePermissionTest, DeactivatePermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FilePermissionTest-begin DeactivatePermission_test_0001"; + int32_t targetCode = EPERM; + if (!CheckFileManagerFullMountEnable()) { + targetCode = E_DEVICENOTSUPPORT; } -} \ No newline at end of file + string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string mediaUri = "file://media/data/storage/el2/base"; + int32_t tokenId = 0; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = inexistentUri; + uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::DeactivatePermission(tokenId, uriPolicies, policyFlag); + EXPECT_EQ(ret, targetCode); + GTEST_LOG_(INFO) << "FilePermissionTest-end DeactivatePermission_test_0001"; +} +} // namespace \ No newline at end of file -- Gitee From fb5a56bfdb04a367746aa194cce6f319d7f5255b Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Fri, 1 Dec 2023 10:33:41 +0800 Subject: [PATCH 02/14] modify Signed-off-by: LVB8189 --- interfaces/innerkits/native/BUILD.gn | 3 - .../file_share/include/file_permission.h | 24 ++- .../native/file_share/src/file_permission.cpp | 48 +----- interfaces/kits/js/BUILD.gn | 4 +- .../js/file_share/fileshare_n_exporter.cpp | 42 ++--- .../kits/js/file_share/fileshare_n_exporter.h | 2 +- .../file_share/grant_multiple_permissions.cpp | 144 +++++++++++------- 7 files changed, 133 insertions(+), 134 deletions(-) diff --git a/interfaces/innerkits/native/BUILD.gn b/interfaces/innerkits/native/BUILD.gn index 63fe0b5e6..55915f338 100644 --- a/interfaces/innerkits/native/BUILD.gn +++ b/interfaces/innerkits/native/BUILD.gn @@ -17,7 +17,6 @@ import("//foundation/filemanagement/app_file_service/app_file_service.gni") config("file_share_config") { visibility = [ ":*" ] include_dirs = [ - "file_permission/include", "file_share/include", "//third_party/json/include", "../../common/include", @@ -59,9 +58,7 @@ ohos_shared_library("fileshare_native") { "ability_base:zuri", "access_token:libaccesstoken_sdk", "c_utils:utils", - "file_api:filemgmt_libn", "hilog:libhilog", - "init:libbegetutil", ] part_name = "app_file_service" diff --git a/interfaces/innerkits/native/file_share/include/file_permission.h b/interfaces/innerkits/native/file_share/include/file_permission.h index fe41d105a..f0976e82a 100644 --- a/interfaces/innerkits/native/file_share/include/file_permission.h +++ b/interfaces/innerkits/native/file_share/include/file_permission.h @@ -23,30 +23,30 @@ namespace OHOS { namespace AppFileService { using namespace std; -typedef enum OperateMode { +typedef enum OperationMode { READ_MODE = 1 << 0, WRITE_MODE = 1 << 1, -} OperateMode; +} OperationMode; typedef enum PolicyFlag { - ALLOWED_PERSIST = 1 << 0, - FORBID_PERSIST = 1 << 1, + ALLOW_PERSISTENCE = 1 << 0, + FORBID_PERSISTENCE = 1 << 1, } PolicyFlag; enum PolicyErrorCode { - FORBIDDEN_TO_BE_PERSISTED = 1, + PERSISTENCE_FORBIDDEN = 1, INVALID_MODE = 2, INVALID_PATH = 3, }; struct UriPolicyInfo { string uri = ""; - uint32_t mode = OperateMode::READ_MODE; + uint32_t mode = OperationMode::READ_MODE; }; struct PolicyInfo { string path = ""; - uint32_t mode = OperateMode::READ_MODE; + uint32_t mode = OperationMode::READ_MODE; }; struct PolicyErrorResult { string uri = ""; - PolicyErrorCode code = PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED; + PolicyErrorCode code = PolicyErrorCode::PERSISTENCE_FORBIDDEN; string message = ""; }; @@ -54,12 +54,10 @@ class FilePermission { public: static int32_t GrantPermission(uint32_t tokenId, vector uriPolicies, uint32_t policyFlag); static int32_t PersistPermission(vector uriPolicies, deque &errorResults); - static int32_t RevokePermission(vector uriPolicies, - deque &errorResults); - static int32_t ActivatePermission(vector uriPolicies, - deque &errorResults); + static int32_t RevokePermission(vector uriPolicies, deque &errorResults); + static int32_t ActivatePermission(vector uriPolicies, deque &errorResults); static int32_t DeactivatePermission(vector uriPolicies, - deque &errorResults); + deque &errorResults); private: static void GetErrorResults(const vector &resultCodes, diff --git a/interfaces/innerkits/native/file_share/src/file_permission.cpp b/interfaces/innerkits/native/file_share/src/file_permission.cpp index d2a11898d..c20a293f9 100644 --- a/interfaces/innerkits/native/file_share/src/file_permission.cpp +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -15,20 +15,16 @@ #include "file_permission.h" #include -#include "filemgmt_libn.h" #include "log.h" -#include "parameter.h" #include "uri.h" namespace OHOS { namespace AppFileService { const std::string MEDIA_AUTHORITY = "media"; const std::string REMOTE_SHARE_PATH_DIR = "/.remote_share"; -const std::string FORBIDDEN_TO_BE_PERSISTED_MESSAGE = "URI refusal to be persisted!"; +const std::string PERSISTENCE_FORBIDDEN_MESSAGE = "URI forbid to be persisted!"; const std::string INVALID_MODE_MESSAGE = "Invalid operation mode!"; const std::string INVALID_PATH_MESSAGE = "Invalid path!"; -const int32_t FULL_MOUNT_ENABLE_SIZE = 6; -const char *FULL_MOUNT_ENABLE_PARAMETER = "const.filemanager.full_mout.enable"; namespace { bool CheckValidUri(const string &uriStr) @@ -45,18 +41,6 @@ bool CheckValidUri(const string &uriStr) } return true; } - -bool CheckFileManagerFullMountEnable() -{ - char value[FULL_MOUNT_ENABLE_SIZE] = "false"; - int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, FULL_MOUNT_ENABLE_SIZE); - if (retSystem > 0 && !strcmp(value, "true")) { - LOGE("The full mount enable parameter is true"); - return true; - } - LOGD("The full mount enable parameter is false"); - return false; -} } // namespace void FilePermission::GetErrorResults(const vector &resultCodes, @@ -66,8 +50,8 @@ void FilePermission::GetErrorResults(const vector &resultCodes, for (int i = 0; i < resultCodes.size(); i++) { PolicyErrorResult result; switch (resultCodes[i]) { - case static_cast(PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED): - result = {resultUris[i], PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED, FORBIDDEN_TO_BE_PERSISTED_MESSAGE}; + case static_cast(PolicyErrorCode::PERSISTENCE_FORBIDDEN): + result = {resultUris[i], PolicyErrorCode::PERSISTENCE_FORBIDDEN, PERSISTENCE_FORBIDDEN_MESSAGE}; errorResults.emplace_back(result); break; case static_cast(PolicyErrorCode::INVALID_MODE): @@ -106,10 +90,6 @@ void FilePermission::GetPolicyInformation(const vector &uriPolici int32_t FilePermission::GrantPermission(uint32_t tokenId, vector uriPolicies, uint32_t policyFlag) { - if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); - return E_DEVICENOTSUPPORT; - } vector policies; vector resultUris; deque errorResults; @@ -127,10 +107,6 @@ int32_t FilePermission::GrantPermission(uint32_t tokenId, vector int32_t FilePermission::PersistPermission(vector uriPolicies, deque &errorResults) { - if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); - return E_DEVICENOTSUPPORT; - } vector policies; vector resultUris; vector resultCodes; @@ -147,12 +123,8 @@ int32_t FilePermission::PersistPermission(vector uriPolicies, } int32_t FilePermission::RevokePermission(vector uriPolicies, - deque &errorResults) + deque &errorResults) { - if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); - return E_DEVICENOTSUPPORT; - } vector policies; vector resultUris; vector resultCodes; @@ -169,12 +141,8 @@ int32_t FilePermission::RevokePermission(vector uriPolicies, } int32_t FilePermission::ActivatePermission(vector uriPolicies, - deque &errorResults) + deque &errorResults) { - if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); - return E_DEVICENOTSUPPORT; - } vector policies; vector resultUris; vector resultCodes; @@ -191,12 +159,8 @@ int32_t FilePermission::ActivatePermission(vector uriPolicies, } int32_t FilePermission::DeactivatePermission(vector uriPolicies, - deque &errorResults) + deque &errorResults) { - if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); - return E_DEVICENOTSUPPORT; - } vector policies; vector resultUris; vector resultCodes; diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index 0645315ca..d16bc992c 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -55,10 +55,11 @@ ohos_shared_library("fileshare") { include_dirs = [ ".", "../../common/include", - "${app_file_service_path}/interfaces/innerkits/native/file_permission/include", + "${app_file_service_path}/interfaces/innerkits/native/file_share/include", ] sources = [ + "../../innerkits/native/file_permission/src/file_permission.cpp", "file_share/fileshare_n_exporter.cpp", "file_share/grant_uri_permission.cpp", "file_share/grant_multiple_permissions.cpp", @@ -79,6 +80,7 @@ ohos_shared_library("fileshare") { "file_api:filemgmt_libn", "file_api:remote_uri_native", "hilog:libhilog", + "init:libbegetutil", "ipc:ipc_core", "napi:ace_napi", ] diff --git a/interfaces/kits/js/file_share/fileshare_n_exporter.cpp b/interfaces/kits/js/file_share/fileshare_n_exporter.cpp index 8df0f1dcb..b4d2f8479 100644 --- a/interfaces/kits/js/file_share/fileshare_n_exporter.cpp +++ b/interfaces/kits/js/file_share/fileshare_n_exporter.cpp @@ -13,18 +13,23 @@ * limitations under the License. */ #include "fileshare_n_exporter.h" -#include "grant_uri_permission.h" +#include "file_permission.h" #include "grant_multiple_permissions.h" +#include "grant_uri_permission.h" +#include "log.h" namespace OHOS { namespace AppFileService { namespace ModuleFileShare { +using namespace FileManagement; +using namespace FileManagement::LibN; + /*********************************************** * Module export and register ***********************************************/ napi_value FileShareExport(napi_env env, napi_value exports) { - InitOperateMode(env, exports); + InitOperationMode(env, exports); InitPolicyFlag(env, exports); InitPolicyInfo(env, exports); InitPolicyErrorCode(env, exports); @@ -41,7 +46,6 @@ napi_value FileShareExport(napi_env env, napi_value exports) return exports; } - static napi_value InitPolicyConstructor(napi_env env, napi_callback_info info) { size_t argc = 0; @@ -56,29 +60,29 @@ static napi_value InitPolicyConstructor(napi_env env, napi_callback_info info) return res; } -void InitOperateMode(napi_env env, napi_value exports) +void InitOperationMode(napi_env env, napi_value exports) { - char propertyName[] = "OperateMode"; + char propertyName[] = "OperationMode"; napi_property_descriptor desc[] = { DECLARE_NAPI_STATIC_PROPERTY("READ_MODE", - NVal::CreateUint32(env, static_cast(OperateMode::READ_MODE)).val_), + NVal::CreateUint32(env, static_cast(OperationMode::READ_MODE)).val_), DECLARE_NAPI_STATIC_PROPERTY("WRITE_MODE", - NVal::CreateUint32(env, static_cast(OperateMode::WRITE_MODE)).val_), + NVal::CreateUint32(env, static_cast(OperationMode::WRITE_MODE)).val_), }; napi_value obj = nullptr; napi_status status = napi_create_object(env, &obj); if (status != napi_ok) { - HILOGE("Failed to create object at initializing OperateMode"); + HILOGE("Failed to create object at initializing OperationMode"); return; } status = napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc); if (status != napi_ok) { - HILOGE("Failed to set properties of character at initializing OperateMode"); + HILOGE("Failed to set properties of character at initializing OperationMode"); return; } status = napi_set_named_property(env, exports, propertyName, obj); if (status != napi_ok) { - HILOGE("Failed to set direction property at initializing OperateMode"); + HILOGE("Failed to set direction property at initializing OperationMode"); return; } } @@ -87,10 +91,10 @@ void InitPolicyFlag(napi_env env, napi_value exports) { char propertyName[] = "PolicyFlag"; napi_property_descriptor desc[] = { - DECLARE_NAPI_STATIC_PROPERTY("ALLOWED_PERSIST", - NVal::CreateUint32(env, static_cast(PolicyFlag::ALLOWED_PERSIST)).val_), - DECLARE_NAPI_STATIC_PROPERTY("FORBID_PERSIST", - NVal::CreateUint32(env, static_cast(PolicyFlag::FORBID_PERSIST)).val_), + DECLARE_NAPI_STATIC_PROPERTY( + "ALLOW_PERSISTENCE", NVal::CreateUint32(env, static_cast(PolicyFlag::ALLOW_PERSISTENCE)).val_), + DECLARE_NAPI_STATIC_PROPERTY( + "FORBID_PERSISTENCE", NVal::CreateUint32(env, static_cast(PolicyFlag::FORBID_PERSISTENCE)).val_), }; napi_value obj = nullptr; napi_status status = napi_create_object(env, &obj); @@ -115,8 +119,8 @@ void InitPolicyErrorCode(napi_env env, napi_value exports) char propertyName[] = "PolicyErrorCode"; napi_property_descriptor desc[] = { DECLARE_NAPI_STATIC_PROPERTY( - "FORBIDDEN_TO_BE_PERSISTED", - NVal::CreateInt32(env, static_cast(PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED)).val_), + "PERSISTENCE_FORBIDDEN", + NVal::CreateInt32(env, static_cast(PolicyErrorCode::PERSISTENCE_FORBIDDEN)).val_), DECLARE_NAPI_STATIC_PROPERTY("INVALID_MODE", NVal::CreateInt32(env, static_cast(PolicyErrorCode::INVALID_MODE)).val_), DECLARE_NAPI_STATIC_PROPERTY("INVALID_PATH", @@ -146,7 +150,7 @@ void InitPolicyErrorResult(napi_env env, napi_value exports) napi_property_descriptor desc[] = { DECLARE_NAPI_STATIC_PROPERTY("uri", NVal::CreateUTF8String(env, "uri").val_), DECLARE_NAPI_STATIC_PROPERTY( - "code", NVal::CreateInt32(env, static_cast(PolicyErrorCode::FORBIDDEN_TO_BE_PERSISTED)).val_), + "code", NVal::CreateInt32(env, static_cast(PolicyErrorCode::PERSISTENCE_FORBIDDEN)).val_), DECLARE_NAPI_STATIC_PROPERTY("message", NVal::CreateUTF8String(env, "message").val_), }; napi_value obj = nullptr; @@ -169,8 +173,8 @@ void InitPolicyInfo(napi_env env, napi_value exports) char className[] = "PolicyInfo"; napi_property_descriptor desc[] = { DECLARE_NAPI_STATIC_PROPERTY("uri", NVal::CreateUTF8String(env, "uri").val_), - DECLARE_NAPI_STATIC_PROPERTY("operaMode", - NVal::CreateUint32(env, static_cast(OperateMode::READ_MODE)).val_), + DECLARE_NAPI_STATIC_PROPERTY("operationMode", + NVal::CreateUint32(env, static_cast(OperationMode::READ_MODE)).val_), }; napi_value obj = nullptr; napi_status status = napi_define_class(env, className, NAPI_AUTO_LENGTH, InitPolicyConstructor, nullptr, diff --git a/interfaces/kits/js/file_share/fileshare_n_exporter.h b/interfaces/kits/js/file_share/fileshare_n_exporter.h index e1490f84a..3b1a82004 100644 --- a/interfaces/kits/js/file_share/fileshare_n_exporter.h +++ b/interfaces/kits/js/file_share/fileshare_n_exporter.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AppFileService { namespace ModuleFileShare { -void InitOperateMode(napi_env env, napi_value exports); +void InitOperationMode(napi_env env, napi_value exports); void InitPolicyFlag(napi_env env, napi_value exports); void InitPolicyInfo(napi_env env, napi_value exports); void InitPolicyErrorResult(napi_env env, napi_value exports); diff --git a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp index 0441bed17..27b3e0b63 100644 --- a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp +++ b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp @@ -21,9 +21,9 @@ #include "accesstoken_kit.h" #include "ipc_skeleton.h" #include "log.h" -#include "tokenid_kit.h" #include "n_napi.h" - +#include "parameter.h" +#include "tokenid_kit.h" namespace OHOS { namespace AppFileService { @@ -31,10 +31,12 @@ namespace ModuleFileShare { using namespace OHOS::FileManagement::LibN; using namespace std; +namespace { const std::string FILE_ACCESS_PERMISSION = "ohos.permission.FILE_ACCESS_PERSIST"; const std::string SET_SANDBOX_POLICY_PERMISSION = "ohos.permission.SET_SANDBOX_POLICY"; +const char *FULL_MOUNT_ENABLE_PARAMETER = "const.filemanager.full_mout.enable"; +const int32_t FULL_MOUNT_ENABLE_SIZE = 6; -namespace { bool IsSystemApp() { uint32_t fullTokenId = OHOS::IPCSkeleton::GetCallingFullTokenID(); @@ -47,6 +49,18 @@ bool CheckPermission(const string &permission) return Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission) == Security::AccessToken::PermissionState::PERMISSION_GRANTED; } + +bool CheckFileManagerFullMountEnable() +{ + char value[FULL_MOUNT_ENABLE_SIZE] = "false"; + int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, FULL_MOUNT_ENABLE_SIZE); + if (retSystem > 0 && !strcmp(value, "true")) { + LOGE("The full mount enable parameter is true"); + return true; + } + LOGD("The full mount enable parameter is false"); + return false; +} } // namespace static napi_value GetErrData(napi_env env, deque &errorResults) @@ -72,7 +86,8 @@ static napi_value GetErrData(napi_env env, deque &erro return res; } -static napi_status GetUriPoliciesArg(napi_env env, napi_value agrv, std::vector &uriPolicies){ +static napi_status GetUriPoliciesArg(napi_env env, napi_value agrv, std::vector &uriPolicies) +{ uint32_t count; napi_status status = napi_get_array_length(env, agrv, &count); if (status != napi_ok) { @@ -106,7 +121,7 @@ static napi_status GetUriPoliciesArg(napi_env env, napi_value agrv, std::vector< } auto [succStr, str, ignore] = NVal(env, uriValue).ToUTF8String(); auto [succMode, mode] = NVal(env, modeValue).ToUint32(); - if(!succStr || !succMode){ + if (!succStr || !succMode) { LOGE("the argument error"); return napi_invalid_arg; } @@ -124,11 +139,6 @@ static napi_status GetUriPoliciesArg(napi_env env, napi_value agrv, std::vector< napi_value GrantPermission(napi_env env, napi_callback_info info) { NFuncArg funcArg(env, info); - if (!funcArg.InitArgs(NARG_CNT::THREE)) { - LOGE("GrantPermission Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); - return nullptr; - } if (!IsSystemApp()) { LOGE("GrantPermission is not System App!"); NError(E_PERMISSION_SYS).ThrowErr(env); @@ -139,10 +149,19 @@ napi_value GrantPermission(napi_env env, napi_callback_info info) NError(E_PERMISSION).ThrowErr(env); return nullptr; } + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + NError(E_DEVICENOTSUPPORT).ThrowErr(env); + return nullptr; + } + if (!funcArg.InitArgs(NARG_CNT::THREE)) { + LOGE("GrantPermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } auto [succTokenId, id] = NVal(env, funcArg[NARG_POS::FIRST]).ToUint32(); auto [succPolicyFlag, flag] = NVal(env, funcArg[NARG_POS::THIRD]).ToUint32(); if (!succTokenId || !succPolicyFlag) { - LOGE("The first/third argument error"); NError(E_PARAMS).ThrowErr(env); return nullptr; } @@ -150,8 +169,7 @@ napi_value GrantPermission(napi_env env, napi_callback_info info) uint32_t policyFlag = flag; std::vector uriPolicies; napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::SECOND], uriPolicies); - if(status != napi_ok){ - LOGE("the second argument error"); + if (status != napi_ok) { NError(E_PARAMS).ThrowErr(env); return nullptr; } @@ -165,7 +183,6 @@ napi_value GrantPermission(napi_env env, napi_callback_info info) } return NVal::CreateUndefined(env); }; - const string procedureName = "grant_permission"; NVal thisVar(env, funcArg.GetThisVar()); return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_; @@ -173,10 +190,9 @@ napi_value GrantPermission(napi_env env, napi_callback_info info) napi_value PersistPermission(napi_env env, napi_callback_info info) { - NFuncArg funcArg(env, info); - if (!funcArg.InitArgs(NARG_CNT::ONE)) { - LOGE("PersistPermission Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + NError(E_DEVICENOTSUPPORT).ThrowErr(env); return nullptr; } if (!CheckPermission(FILE_ACCESS_PERMISSION)) { @@ -184,16 +200,19 @@ napi_value PersistPermission(napi_env env, napi_callback_info info) NError(E_PERMISSION).ThrowErr(env); return nullptr; } + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + LOGE("PersistPermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } std::vector uriPolicies; - napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); - if(status != napi_ok){ - LOGE("get arguments failed"); + if (GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies) != napi_ok) { NError(E_PARAMS).ThrowErr(env); return nullptr; } shared_ptr arg = make_shared(); if (arg == nullptr) { - LOGE("Failed to request heap memory."); NError(EILSEQ).ThrowErr(env); return nullptr; } @@ -203,14 +222,14 @@ napi_value PersistPermission(napi_env env, napi_callback_info info) }; auto cbCompl = [arg](napi_env env, NError err) -> NVal { if (err) { - if(arg->errNo == EPERM){ + if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), - GetErrData(env, arg->errorResults)); + napi_status status = + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); if (status != napi_ok) { LOGE("Failed to set data property on Error"); } - return { env, data }; + return {env, data}; } return {env, err.GetNapiErr(env)}; } @@ -223,10 +242,9 @@ napi_value PersistPermission(napi_env env, napi_callback_info info) napi_value RevokePermission(napi_env env, napi_callback_info info) { - NFuncArg funcArg(env, info); - if (!funcArg.InitArgs(NARG_CNT::ONE)) { - LOGE("RevokePermission Number of arguments unmatched"); - NError(E_PARAMS).ThrowErr(env); + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + NError(E_DEVICENOTSUPPORT).ThrowErr(env); return nullptr; } if (!CheckPermission(FILE_ACCESS_PERMISSION)) { @@ -234,16 +252,19 @@ napi_value RevokePermission(napi_env env, napi_callback_info info) NError(E_PERMISSION).ThrowErr(env); return nullptr; } + NFuncArg funcArg(env, info); + if (!funcArg.InitArgs(NARG_CNT::ONE)) { + LOGE("RevokePermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } std::vector uriPolicies; - napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); - if(status != napi_ok){ - LOGE("get arguments failed"); + if (GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies) != napi_ok) { NError(E_PARAMS).ThrowErr(env); return nullptr; } shared_ptr arg = make_shared(); if (arg == nullptr) { - LOGE("Failed to request heap memory."); NError(EILSEQ).ThrowErr(env); return nullptr; } @@ -253,14 +274,14 @@ napi_value RevokePermission(napi_env env, napi_callback_info info) }; auto cbCompl = [arg](napi_env env, NError err) -> NVal { if (err) { - if(arg->errNo == EPERM){ + if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), - GetErrData(env, arg->errorResults)); + napi_status status = + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); if (status != napi_ok) { LOGE("Failed to set data property on Error"); } - return { env, data }; + return {env, data}; } return {env, err.GetNapiErr(env)}; } @@ -273,6 +294,16 @@ napi_value RevokePermission(napi_env env, napi_callback_info info) napi_value ActivatePermission(napi_env env, napi_callback_info info) { + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + NError(E_DEVICENOTSUPPORT).ThrowErr(env); + return nullptr; + } + if (!CheckPermission(FILE_ACCESS_PERMISSION)) { + LOGE("PersistPermission has not ohos permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ONE)) { LOGE("ActivatePermission Number of arguments unmatched"); @@ -280,15 +311,12 @@ napi_value ActivatePermission(napi_env env, napi_callback_info info) return nullptr; } std::vector uriPolicies; - napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); - if(status != napi_ok){ - LOGE("get arguments failed"); + if (GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies) != napi_ok) { NError(E_PARAMS).ThrowErr(env); return nullptr; } shared_ptr arg = make_shared(); if (arg == nullptr) { - LOGE("Failed to request heap memory."); NError(EILSEQ).ThrowErr(env); return nullptr; } @@ -298,14 +326,14 @@ napi_value ActivatePermission(napi_env env, napi_callback_info info) }; auto cbCompl = [arg](napi_env env, NError err) -> NVal { if (err) { - if(arg->errNo == EPERM){ + if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), - GetErrData(env, arg->errorResults)); + napi_status status = + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); if (status != napi_ok) { LOGE("Failed to set data property on Error"); } - return { env, data }; + return {env, data}; } return {env, err.GetNapiErr(env)}; } @@ -318,6 +346,16 @@ napi_value ActivatePermission(napi_env env, napi_callback_info info) napi_value DeactivatePermission(napi_env env, napi_callback_info info) { + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this apil"); + NError(E_DEVICENOTSUPPORT).ThrowErr(env); + return nullptr; + } + if (!CheckPermission(FILE_ACCESS_PERMISSION)) { + LOGE("PersistPermission has not ohos permission!"); + NError(E_PERMISSION).ThrowErr(env); + return nullptr; + } NFuncArg funcArg(env, info); if (!funcArg.InitArgs(NARG_CNT::ONE)) { LOGE("DeactivatePermission Number of arguments unmatched"); @@ -325,16 +363,12 @@ napi_value DeactivatePermission(napi_env env, napi_callback_info info) return nullptr; } std::vector uriPolicies; - napi_status status = GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies); - if(status != napi_ok){ - LOGE("get arguments failed"); + if (GetUriPoliciesArg(env, funcArg[NARG_POS::FIRST], uriPolicies) != napi_ok) { NError(E_PARAMS).ThrowErr(env); return nullptr; } - LOGE("DeactivatePermission %{public}d", uriPolicies.size()); shared_ptr arg = make_shared(); if (arg == nullptr) { - LOGE("Failed to request heap memory."); NError(EILSEQ).ThrowErr(env); return nullptr; } @@ -344,14 +378,14 @@ napi_value DeactivatePermission(napi_env env, napi_callback_info info) }; auto cbCompl = [arg](napi_env env, NError err) -> NVal { if (err) { - if(arg->errNo == EPERM){ + if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), - GetErrData(env, arg->errorResults)); + napi_status status = + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); if (status != napi_ok) { LOGE("Failed to set data property on Error"); } - return { env, data }; + return {env, data}; } return {env, err.GetNapiErr(env)}; } -- Gitee From 2362b870eff18108ac504374426c3be49e9d4515 Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Fri, 1 Dec 2023 10:47:45 +0800 Subject: [PATCH 03/14] modify Signed-off-by: LVB8189 --- interfaces/kits/js/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index d16bc992c..7693b0952 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -59,7 +59,7 @@ ohos_shared_library("fileshare") { ] sources = [ - "../../innerkits/native/file_permission/src/file_permission.cpp", + "../../innerkits/native/file_share/src/file_permission.cpp", "file_share/fileshare_n_exporter.cpp", "file_share/grant_uri_permission.cpp", "file_share/grant_multiple_permissions.cpp", -- Gitee From d1b8874e6884fc313b570f02c3d61f45ef092a83 Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Fri, 1 Dec 2023 15:58:49 +0800 Subject: [PATCH 04/14] modify Signed-off-by: LVB8189 --- .../file_share/grant_multiple_permissions.cpp | 18 +- test/unittest/file_share_native/BUILD.gn | 2 - .../file_share_native/file_share_test.cpp | 192 +++++++----------- 3 files changed, 79 insertions(+), 133 deletions(-) diff --git a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp index 27b3e0b63..f03955eb3 100644 --- a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp +++ b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp @@ -138,6 +138,11 @@ static napi_status GetUriPoliciesArg(napi_env env, napi_value agrv, std::vector< napi_value GrantPermission(napi_env env, napi_callback_info info) { + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this api"); + NError(E_DEVICENOTSUPPORT).ThrowErr(env); + return nullptr; + } NFuncArg funcArg(env, info); if (!IsSystemApp()) { LOGE("GrantPermission is not System App!"); @@ -149,11 +154,6 @@ napi_value GrantPermission(napi_env env, napi_callback_info info) NError(E_PERMISSION).ThrowErr(env); return nullptr; } - if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); - NError(E_DEVICENOTSUPPORT).ThrowErr(env); - return nullptr; - } if (!funcArg.InitArgs(NARG_CNT::THREE)) { LOGE("GrantPermission Number of arguments unmatched"); NError(E_PARAMS).ThrowErr(env); @@ -191,7 +191,7 @@ napi_value GrantPermission(napi_env env, napi_callback_info info) napi_value PersistPermission(napi_env env, napi_callback_info info) { if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); + LOGE("The device doesn't support this api"); NError(E_DEVICENOTSUPPORT).ThrowErr(env); return nullptr; } @@ -243,7 +243,7 @@ napi_value PersistPermission(napi_env env, napi_callback_info info) napi_value RevokePermission(napi_env env, napi_callback_info info) { if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); + LOGE("The device doesn't support this api"); NError(E_DEVICENOTSUPPORT).ThrowErr(env); return nullptr; } @@ -295,7 +295,7 @@ napi_value RevokePermission(napi_env env, napi_callback_info info) napi_value ActivatePermission(napi_env env, napi_callback_info info) { if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); + LOGE("The device doesn't support this api"); NError(E_DEVICENOTSUPPORT).ThrowErr(env); return nullptr; } @@ -347,7 +347,7 @@ napi_value ActivatePermission(napi_env env, napi_callback_info info) napi_value DeactivatePermission(napi_env env, napi_callback_info info) { if (!CheckFileManagerFullMountEnable()) { - LOGE("The device doesn't support this apil"); + LOGE("The device doesn't support this api"); NError(E_DEVICENOTSUPPORT).ThrowErr(env); return nullptr; } diff --git a/test/unittest/file_share_native/BUILD.gn b/test/unittest/file_share_native/BUILD.gn index e03c69119..17dd4d7a4 100644 --- a/test/unittest/file_share_native/BUILD.gn +++ b/test/unittest/file_share_native/BUILD.gn @@ -25,9 +25,7 @@ ohos_unittest("file_share_test") { "access_token:libaccesstoken_sdk", "app_file_service:fileshare_native", "c_utils:utils", - "file_api:filemgmt_libn", "hilog:libhilog", - "init:libbegetutil", "ipc:ipc_core", ] } diff --git a/test/unittest/file_share_native/file_share_test.cpp b/test/unittest/file_share_native/file_share_test.cpp index 7b44c6cec..224d6332e 100644 --- a/test/unittest/file_share_native/file_share_test.cpp +++ b/test/unittest/file_share_native/file_share_test.cpp @@ -15,7 +15,6 @@ #include #include -#include #include #include @@ -28,10 +27,8 @@ #include "accesstoken_kit.h" #include "file_permission.h" #include "file_share.h" -#include "filemgmt_libn.h" #include "ipc_skeleton.h" #include "log.h" -#include "parameter.h" #include "sandbox_helper.h" #include "uri.h" @@ -50,15 +47,6 @@ public: void SetUp() {}; void TearDown() {}; }; -bool CheckFileManagerFullMountEnable() -{ - char value[FULL_MOUNT_ENABLE_SIZE] = "false"; - int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, FULL_MOUNT_ENABLE_SIZE); - if (retSystem > 0 && !strcmp(value, "true")) { - return true; - } - return false; -} /** * @tc.name: file_share_test_0000 @@ -435,23 +423,19 @@ HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0006, testing::ext::TestSize. * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, GrantPermission_test_0000, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, GrantPermission_test_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin GrantPermission"; - int32_t targetCode = 0; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin GrantPermission"; string uri = "file://" + bundleA + "/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uint32_t policyFlag = PolicyFlag::ALLOW_PERSISTENCE; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::GrantPermission(tokenId, uriPolicies, policyFlag); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end GrantPermission"; + int32_t ret = FilePermission::GrantPermission(0, uriPolicies, policyFlag); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-end GrantPermission"; } /** @@ -462,26 +446,22 @@ HWTEST_F(FilePermissionTest, GrantPermission_test_0000, testing::ext::TestSize.L * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, GrantPermission_test_0001, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, GrantPermission_test_0001, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin GrantPermission_test_0001"; - int32_t targetCode = EPERM; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin GrantPermission_test_0001"; string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = inexistentUri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uint32_t policyFlag = PolicyFlag::ALLOW_PERSISTENCE; uriPolicies.emplace_back(uriPolicyInfo); uriPolicyInfo.uri = mediaUri; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::GrantPermission(tokenId, uriPolicies, policyFlag); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end GrantPermission_test_0001"; + int32_t ret = FilePermission::GrantPermission(0, uriPolicies, policyFlag); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-end GrantPermission_test_0001"; } /** @@ -492,23 +472,19 @@ HWTEST_F(FilePermissionTest, GrantPermission_test_0001, testing::ext::TestSize.L * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, PersistPermission_test_0000, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, PersistPermission_test_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin PersistPermission_test_0000"; - int32_t targetCode = 0; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0000"; string uri = "file://" + bundleA + "/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::PersistPermission(uriPolicies); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end PersistPermission_test_0000"; + deque errorResults; + int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0000"; } /** @@ -519,26 +495,22 @@ HWTEST_F(FilePermissionTest, PersistPermission_test_0000, testing::ext::TestSize * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, PersistPermission_test_0001, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, PersistPermission_test_0001, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin PersistPermission_test_0001"; - int32_t targetCode = EPERM; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0001"; string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = inexistentUri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); uriPolicyInfo.uri = mediaUri; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::PersistPermission(tokenId, uriPolicies, policyFlag); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end PersistPermission_test_0001"; + deque errorResults; + int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-end PersistPermission_test_0001"; } /** @@ -549,23 +521,19 @@ HWTEST_F(FilePermissionTest, PersistPermission_test_0001, testing::ext::TestSize * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, DesistPersistedPermission_test_0000, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, DesistPersistedPermission_test_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin DesistPersistedPermission_test_0000"; - int32_t targetCode = 0; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin DesistPersistedPermission_test_0000"; string uri = "file://" + bundleA + "/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::RevokePermission(uriPolicies); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end DesistPersistedPermission_test_0000"; + deque errorResults; + int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-end DesistPersistedPermission_test_0000"; } /** @@ -576,26 +544,22 @@ HWTEST_F(FilePermissionTest, DesistPersistedPermission_test_0000, testing::ext:: * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, DesistPersistedPermission_test_0001, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, DesistPersistedPermission_test_0001, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin DesistPersistedPermission_test_0001"; - int32_t targetCode = EPERM; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin DesistPersistedPermission_test_0001"; string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = inexistentUri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); uriPolicyInfo.uri = mediaUri; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::RevokePermission(tokenId, uriPolicies, policyFlag); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end DesistPersistedPermission_test_0001"; + deque errorResults; + int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-end DesistPersistedPermission_test_0001"; } /** @@ -606,23 +570,19 @@ HWTEST_F(FilePermissionTest, DesistPersistedPermission_test_0001, testing::ext:: * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin ActivatePermission_test_0000"; - int32_t targetCode = 0; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0000"; string uri = "file://" + bundleA + "/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::ActivatePermission(uriPolicies); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end ActivatePermission_test_0000"; + deque errorResults; + int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0000"; } /** @@ -633,26 +593,22 @@ HWTEST_F(FilePermissionTest, ActivatePermission_test_0000, testing::ext::TestSiz * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, ActivatePermission_test_0001, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, ActivatePermission_test_0001, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin ActivatePermission_test_0001"; - int32_t targetCode = EPERM; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0001"; string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = inexistentUri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); uriPolicyInfo.uri = mediaUri; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::ActivatePermission(tokenId, uriPolicies, policyFlag); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end ActivatePermission_test_0001"; + deque errorResults; + int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-end ActivatePermission_test_0001"; } /** @@ -663,23 +619,19 @@ HWTEST_F(FilePermissionTest, ActivatePermission_test_0001, testing::ext::TestSiz * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin DeactivatePermission_test_0000"; - int32_t targetCode = 0; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0000"; string uri = "file://" + bundleA + "/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::DeactivatePermission(uriPolicies); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end DeactivatePermission_test_0000"; + deque errorResults; + int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0000"; } /** @@ -690,25 +642,21 @@ HWTEST_F(FilePermissionTest, DeactivatePermission_test_0000, testing::ext::TestS * @tc.level Level 1 * @tc.require: */ -HWTEST_F(FilePermissionTest, DeactivatePermission_test_0001, testing::ext::TestSize.Level1) +HWTEST_F(FileShareTest, DeactivatePermission_test_0001, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "FilePermissionTest-begin DeactivatePermission_test_0001"; - int32_t targetCode = EPERM; - if (!CheckFileManagerFullMountEnable()) { - targetCode = E_DEVICENOTSUPPORT; - } + GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0001"; string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; - int32_t tokenId = 0; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = inexistentUri; - uint32_t policyFlag = OperateMode::READ_MODE | OperateMode::WRITE_MODE; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; uriPolicies.emplace_back(uriPolicyInfo); uriPolicyInfo.uri = mediaUri; uriPolicies.emplace_back(uriPolicyInfo); - int32_t ret = FilePermission::DeactivatePermission(tokenId, uriPolicies, policyFlag); - EXPECT_EQ(ret, targetCode); - GTEST_LOG_(INFO) << "FilePermissionTest-end DeactivatePermission_test_0001"; + deque errorResults; + int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-end DeactivatePermission_test_0001"; } } // namespace \ No newline at end of file -- Gitee From cd4d7288cde1a345d98606d6534c33475e5a7e8f Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Fri, 1 Dec 2023 19:57:50 +0800 Subject: [PATCH 05/14] modify Signed-off-by: LVB8189 --- interfaces/kits/js/file_share/grant_multiple_permissions.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp index f03955eb3..34c73856e 100644 --- a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp +++ b/interfaces/kits/js/file_share/grant_multiple_permissions.cpp @@ -114,7 +114,7 @@ static napi_status GetUriPoliciesArg(napi_env env, napi_value agrv, std::vector< LOGE("get named property failed"); return status; } - status = napi_get_named_property(env, object, "operateMode", &modeValue); + status = napi_get_named_property(env, object, "operationMode", &modeValue); if (status != napi_ok) { LOGE("get named property failed"); return status; -- Gitee From fd8a425147f98af8c1f6626ce901c89648f4aae2 Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 11:06:40 +0800 Subject: [PATCH 06/14] modify Signed-off-by: LVB8189 --- .../native/file_share/src/file_permission.cpp | 1 - test/unittest/file_share_native/file_share_test.cpp | 10 +++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/interfaces/innerkits/native/file_share/src/file_permission.cpp b/interfaces/innerkits/native/file_share/src/file_permission.cpp index c20a293f9..8cc5132af 100644 --- a/interfaces/innerkits/native/file_share/src/file_permission.cpp +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -175,6 +175,5 @@ int32_t FilePermission::DeactivatePermission(vector uriPolicies, LOGD("DeactivatePermission success"); return 0; } - } // namespace AppFileService } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/file_share_native/file_share_test.cpp b/test/unittest/file_share_native/file_share_test.cpp index 224d6332e..6101dbd77 100644 --- a/test/unittest/file_share_native/file_share_test.cpp +++ b/test/unittest/file_share_native/file_share_test.cpp @@ -426,7 +426,7 @@ HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0006, testing::ext::TestSize. HWTEST_F(FileShareTest, GrantPermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin GrantPermission"; - string uri = "file://" + bundleA + "/data/storage/el2/base"; + string uri = "file://" + bundleA + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -475,7 +475,7 @@ HWTEST_F(FileShareTest, GrantPermission_test_0001, testing::ext::TestSize.Level1 HWTEST_F(FileShareTest, PersistPermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0000"; - string uri = "file://" + bundleA + "/data/storage/el2/base"; + string uri = "file://" + bundleA + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -524,7 +524,7 @@ HWTEST_F(FileShareTest, PersistPermission_test_0001, testing::ext::TestSize.Leve HWTEST_F(FileShareTest, DesistPersistedPermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin DesistPersistedPermission_test_0000"; - string uri = "file://" + bundleA + "/data/storage/el2/base"; + string uri = "file://" + bundleA + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -573,7 +573,7 @@ HWTEST_F(FileShareTest, DesistPersistedPermission_test_0001, testing::ext::TestS HWTEST_F(FileShareTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0000"; - string uri = "file://" + bundleA + "/data/storage/el2/base"; + string uri = "file://" + bundleA + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -622,7 +622,7 @@ HWTEST_F(FileShareTest, ActivatePermission_test_0001, testing::ext::TestSize.Lev HWTEST_F(FileShareTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0000"; - string uri = "file://" + bundleA + "/data/storage/el2/base"; + string uri = "file://" + bundleA + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; -- Gitee From 1eaeaa3c3b2d68b164e8c76214ede5b6745da50a Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 16:27:33 +0800 Subject: [PATCH 07/14] modify Signed-off-by: LVB8189 --- .../file_share/include/file_permission.h | 33 ++++---- .../native/file_share/src/file_permission.cpp | 76 +++++++++---------- interfaces/kits/js/BUILD.gn | 2 +- .../js/file_share/fileshare_n_exporter.cpp | 2 +- ..._permissions.cpp => grant_permissions.cpp} | 13 ++-- ...iple_permissions.h => grant_permissions.h} | 6 +- 6 files changed, 66 insertions(+), 66 deletions(-) rename interfaces/kits/js/file_share/{grant_multiple_permissions.cpp => grant_permissions.cpp} (98%) rename interfaces/kits/js/file_share/{grant_multiple_permissions.h => grant_permissions.h} (92%) diff --git a/interfaces/innerkits/native/file_share/include/file_permission.h b/interfaces/innerkits/native/file_share/include/file_permission.h index f0976e82a..ae2f5bcd7 100644 --- a/interfaces/innerkits/native/file_share/include/file_permission.h +++ b/interfaces/innerkits/native/file_share/include/file_permission.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef APP_FILE_SERVICE_FILE_PERMISSION -#define APP_FILE_SERVICE_FILE_PERMISSION +#ifndef _APP_FILE_SERVICE_FILE_PERMISSION_ +#define _APP_FILE_SERVICE_FILE_PERMISSION_ #include #include @@ -27,23 +27,28 @@ typedef enum OperationMode { READ_MODE = 1 << 0, WRITE_MODE = 1 << 1, } OperationMode; + typedef enum PolicyFlag { ALLOW_PERSISTENCE = 1 << 0, FORBID_PERSISTENCE = 1 << 1, } PolicyFlag; + enum PolicyErrorCode { PERSISTENCE_FORBIDDEN = 1, INVALID_MODE = 2, INVALID_PATH = 3, }; + struct UriPolicyInfo { string uri = ""; uint32_t mode = OperationMode::READ_MODE; }; -struct PolicyInfo { + +struct PathPolicyInfo { string path = ""; uint32_t mode = OperationMode::READ_MODE; }; + struct PolicyErrorResult { string uri = ""; PolicyErrorCode code = PolicyErrorCode::PERSISTENCE_FORBIDDEN; @@ -52,21 +57,23 @@ struct PolicyErrorResult { class FilePermission { public: - static int32_t GrantPermission(uint32_t tokenId, vector uriPolicies, uint32_t policyFlag); - static int32_t PersistPermission(vector uriPolicies, deque &errorResults); - static int32_t RevokePermission(vector uriPolicies, deque &errorResults); - static int32_t ActivatePermission(vector uriPolicies, deque &errorResults); - static int32_t DeactivatePermission(vector uriPolicies, + static int32_t GrantPermission(uint32_t tokenId, const vector &uriPolicies, uint32_t policyFlag); + static int32_t PersistPermission(const vector &uriPolicies, + deque &errorResults); + static int32_t RevokePermission(const vector &uriPolicies, + deque &errorResults); + static int32_t ActivatePermission(const vector &uriPolicies, + deque &errorResults); + static int32_t DeactivatePermission(const vector &uriPolicies, deque &errorResults); private: static void GetErrorResults(const vector &resultCodes, - const vector &resultUris, + const vector &pathPolicies, deque &errorResults); - static void GetPolicyInformation(const vector &uriPolicies, - vector &resultUris, - deque &errorResults, - vector &policies); + static void GetPathPolicyInfoFromUriPolicyInfo(const vector &uriPolicies, + deque &errorResults, + vector &pathPolicies); }; } // namespace AppFileService } // namespace OHOS diff --git a/interfaces/innerkits/native/file_share/src/file_permission.cpp b/interfaces/innerkits/native/file_share/src/file_permission.cpp index 8cc5132af..d53c4617e 100644 --- a/interfaces/innerkits/native/file_share/src/file_permission.cpp +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -25,10 +25,15 @@ const std::string REMOTE_SHARE_PATH_DIR = "/.remote_share"; const std::string PERSISTENCE_FORBIDDEN_MESSAGE = "URI forbid to be persisted!"; const std::string INVALID_MODE_MESSAGE = "Invalid operation mode!"; const std::string INVALID_PATH_MESSAGE = "Invalid path!"; +const std::string FILE_SCHEME_PREFIX = "file://"; namespace { bool CheckValidUri(const string &uriStr) { + if(!uriStr.find(FILE_SCHEME_PREFIX)){ + LOGE("Incorrect URI format!"); + return false; + } Uri uri(uriStr); std::string bundleName = uri.GetAuthority(); if (bundleName == MEDIA_AUTHORITY) { @@ -44,22 +49,23 @@ bool CheckValidUri(const string &uriStr) } // namespace void FilePermission::GetErrorResults(const vector &resultCodes, - const vector &resultUris, + const vector &pathPolicies, deque &errorResults) { for (int i = 0; i < resultCodes.size(); i++) { PolicyErrorResult result; + Uri uri(pathPolicies[i].path); switch (resultCodes[i]) { case static_cast(PolicyErrorCode::PERSISTENCE_FORBIDDEN): - result = {resultUris[i], PolicyErrorCode::PERSISTENCE_FORBIDDEN, PERSISTENCE_FORBIDDEN_MESSAGE}; + result = {uri.ToString(), PolicyErrorCode::PERSISTENCE_FORBIDDEN, PERSISTENCE_FORBIDDEN_MESSAGE}; errorResults.emplace_back(result); break; case static_cast(PolicyErrorCode::INVALID_MODE): - result = {resultUris[i], PolicyErrorCode::INVALID_MODE, INVALID_MODE_MESSAGE}; + result = {uri.ToString(), PolicyErrorCode::INVALID_MODE, INVALID_MODE_MESSAGE}; errorResults.emplace_back(result); break; case static_cast(PolicyErrorCode::INVALID_PATH): - result = {resultUris[i], PolicyErrorCode::INVALID_PATH, INVALID_PATH_MESSAGE}; + result = {uri.ToString(), PolicyErrorCode::INVALID_PATH, INVALID_PATH_MESSAGE}; errorResults.emplace_back(result); break; default: @@ -68,34 +74,30 @@ void FilePermission::GetErrorResults(const vector &resultCodes, } } -void FilePermission::GetPolicyInformation(const vector &uriPolicies, - vector &resultUris, - deque &errorResults, - vector &policies) +void FilePermission::GetPathPolicyInfoFromUriPolicyInfo(const vector &uriPolicies, + deque &errorResults, + vector &pathPolicies) { for (auto uriPolicy : uriPolicies) { Uri uri(uriPolicy.uri); string path = uri.GetPath(); if (!CheckValidUri(uriPolicy.uri) || access(path.c_str(), F_OK) != 0) { - LOGE("Not the correct uri!"); + LOGE("Not correct uri!"); PolicyErrorResult result = {uriPolicy.uri, PolicyErrorCode::INVALID_PATH, INVALID_PATH_MESSAGE}; errorResults.emplace_back(result); } else { - PolicyInfo policyInfo = {path, uriPolicy.mode}; - policies.emplace_back(policyInfo); - resultUris.emplace_back(uriPolicy.uri); + PathPolicyInfo policyInfo = {path, uriPolicy.mode}; + pathPolicies.emplace_back(policyInfo); } } } -int32_t FilePermission::GrantPermission(uint32_t tokenId, vector uriPolicies, uint32_t policyFlag) +int32_t FilePermission::GrantPermission(uint32_t tokenId, const vector &uriPolicies, uint32_t policyFlag) { - vector policies; - vector resultUris; + vector pathPolicies; deque errorResults; - GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); // SandboxManager interface call - // int32_t SandboxRet = SandboxManager::GrantPermission(tokenId, resultCodes); if (!errorResults.empty()) { LOGE("There are some URI operations that fail"); return EPERM; @@ -104,16 +106,14 @@ int32_t FilePermission::GrantPermission(uint32_t tokenId, vector return 0; } -int32_t FilePermission::PersistPermission(vector uriPolicies, +int32_t FilePermission::PersistPermission(const vector &uriPolicies, deque &errorResults) { - vector policies; - vector resultUris; + vector pathPolicies; vector resultCodes; - GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); // SandboxManager interface call - // int32_t SandboxRet = SandboxManager::PersistPermission(policies, resultCodes); - GetErrorResults(resultCodes, resultUris, errorResults); + GetErrorResults(resultCodes, pathPolicies, errorResults); if (!errorResults.empty()) { LOGE("There are some URI operations that fail"); return EPERM; @@ -122,16 +122,14 @@ int32_t FilePermission::PersistPermission(vector uriPolicies, return 0; } -int32_t FilePermission::RevokePermission(vector uriPolicies, +int32_t FilePermission::RevokePermission(const vector &uriPolicies, deque &errorResults) { - vector policies; - vector resultUris; + vector pathPolicies; vector resultCodes; - GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); // SandboxManager interface call - // int32_t SandboxRet = SandboxManager::RevokePermission(policies, resultCodes); - GetErrorResults(resultCodes, resultUris, errorResults); + GetErrorResults(resultCodes, pathPolicies, errorResults); if (!errorResults.empty()) { LOGE("There are some URI operations that fail"); return EPERM; @@ -140,16 +138,14 @@ int32_t FilePermission::RevokePermission(vector uriPolicies, return 0; } -int32_t FilePermission::ActivatePermission(vector uriPolicies, +int32_t FilePermission::ActivatePermission(const vector &uriPolicies, deque &errorResults) { - vector policies; - vector resultUris; + vector pathPolicies; vector resultCodes; - GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); // SandboxManager interface call - // int32_t SandboxRet = SandboxManager::ActivatePermission(policies, resultCodes); - GetErrorResults(resultCodes, resultUris, errorResults); + GetErrorResults(resultCodes, pathPolicies, errorResults); if (!errorResults.empty()) { LOGE("There are some URI operations that fail"); return EPERM; @@ -158,16 +154,14 @@ int32_t FilePermission::ActivatePermission(vector uriPolicies, return 0; } -int32_t FilePermission::DeactivatePermission(vector uriPolicies, +int32_t FilePermission::DeactivatePermission(const vector &uriPolicies, deque &errorResults) { - vector policies; - vector resultUris; + vector pathPolicies; vector resultCodes; - GetPolicyInformation(uriPolicies, resultUris, errorResults, policies); + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); // SandboxManager interface call - // int32_t SandboxRet = SandboxManager::DeactivatePermission(policies, resultCodes); - GetErrorResults(resultCodes, resultUris, errorResults); + GetErrorResults(resultCodes, pathPolicies, errorResults); if (!errorResults.empty()) { LOGE("There are some URI operations that fail"); return EPERM; diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index 7693b0952..213f28874 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -62,7 +62,7 @@ ohos_shared_library("fileshare") { "../../innerkits/native/file_share/src/file_permission.cpp", "file_share/fileshare_n_exporter.cpp", "file_share/grant_uri_permission.cpp", - "file_share/grant_multiple_permissions.cpp", + "file_share/grant_permissions.cpp", ] external_deps = [ diff --git a/interfaces/kits/js/file_share/fileshare_n_exporter.cpp b/interfaces/kits/js/file_share/fileshare_n_exporter.cpp index b4d2f8479..f9eceee4e 100644 --- a/interfaces/kits/js/file_share/fileshare_n_exporter.cpp +++ b/interfaces/kits/js/file_share/fileshare_n_exporter.cpp @@ -14,7 +14,7 @@ */ #include "fileshare_n_exporter.h" #include "file_permission.h" -#include "grant_multiple_permissions.h" +#include "grant_permissions.h" #include "grant_uri_permission.h" #include "log.h" diff --git a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp b/interfaces/kits/js/file_share/grant_permissions.cpp similarity index 98% rename from interfaces/kits/js/file_share/grant_multiple_permissions.cpp rename to interfaces/kits/js/file_share/grant_permissions.cpp index 34c73856e..5bb4f9a06 100644 --- a/interfaces/kits/js/file_share/grant_multiple_permissions.cpp +++ b/interfaces/kits/js/file_share/grant_permissions.cpp @@ -12,7 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "grant_multiple_permissions.h" +#include "grant_permissions.h" #include #include @@ -35,25 +35,24 @@ namespace { const std::string FILE_ACCESS_PERMISSION = "ohos.permission.FILE_ACCESS_PERSIST"; const std::string SET_SANDBOX_POLICY_PERMISSION = "ohos.permission.SET_SANDBOX_POLICY"; const char *FULL_MOUNT_ENABLE_PARAMETER = "const.filemanager.full_mout.enable"; -const int32_t FULL_MOUNT_ENABLE_SIZE = 6; -bool IsSystemApp() +static bool IsSystemApp() { uint32_t fullTokenId = OHOS::IPCSkeleton::GetCallingFullTokenID(); return Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(fullTokenId); } -bool CheckPermission(const string &permission) +static bool CheckPermission(const string &permission) { Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID(); return Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission) == Security::AccessToken::PermissionState::PERMISSION_GRANTED; } -bool CheckFileManagerFullMountEnable() +static bool CheckFileManagerFullMountEnable() { - char value[FULL_MOUNT_ENABLE_SIZE] = "false"; - int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, FULL_MOUNT_ENABLE_SIZE); + char value[] = "false"; + int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, sizeof(value)); if (retSystem > 0 && !strcmp(value, "true")) { LOGE("The full mount enable parameter is true"); return true; diff --git a/interfaces/kits/js/file_share/grant_multiple_permissions.h b/interfaces/kits/js/file_share/grant_permissions.h similarity index 92% rename from interfaces/kits/js/file_share/grant_multiple_permissions.h rename to interfaces/kits/js/file_share/grant_permissions.h index 1498f7fea..7ff720659 100644 --- a/interfaces/kits/js/file_share/grant_multiple_permissions.h +++ b/interfaces/kits/js/file_share/grant_permissions.h @@ -13,9 +13,9 @@ * limitations under the License. */ -#ifndef GRANT_MULTIPLE_PERMISSIONS_H +#ifndef _GRANT_PERMISSIONS_H_ -#define GRANT_MULTIPLE_PERMISSIONS_H +#define _GRANT_PERMISSIONS_H_ #include @@ -39,4 +39,4 @@ struct PolicyErrorArgs { } // namespace ModuleFileShare } // namespace AppFileService } // namespace OHOS -#endif // GRANT_MULTIPLE_PERMISSIONS_H +#endif // _GRANT_PERMISSIONS_H_ -- Gitee From 4b31fb4a93b999794de3964b50421e75ee89e223 Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 16:42:06 +0800 Subject: [PATCH 08/14] modify Signed-off-by: LVB8189 --- interfaces/innerkits/native/file_share/src/file_permission.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/innerkits/native/file_share/src/file_permission.cpp b/interfaces/innerkits/native/file_share/src/file_permission.cpp index d53c4617e..4fe1cf461 100644 --- a/interfaces/innerkits/native/file_share/src/file_permission.cpp +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -30,7 +30,7 @@ const std::string FILE_SCHEME_PREFIX = "file://"; namespace { bool CheckValidUri(const string &uriStr) { - if(!uriStr.find(FILE_SCHEME_PREFIX)){ + if(uriStr.find(FILE_SCHEME_PREFIX) != 0){ LOGE("Incorrect URI format!"); return false; } -- Gitee From 2dda2855b79cebbf2009ff8ede2699c0a998a349 Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 20:28:08 +0800 Subject: [PATCH 09/14] modify Signed-off-by: LVB8189 --- .../innerkits/native/file_share/src/file_permission.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/interfaces/innerkits/native/file_share/src/file_permission.cpp b/interfaces/innerkits/native/file_share/src/file_permission.cpp index 4fe1cf461..823618277 100644 --- a/interfaces/innerkits/native/file_share/src/file_permission.cpp +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -21,7 +21,7 @@ namespace OHOS { namespace AppFileService { const std::string MEDIA_AUTHORITY = "media"; -const std::string REMOTE_SHARE_PATH_DIR = "/.remote_share"; +const std::string NETWORK_PARA = "?networkid="; const std::string PERSISTENCE_FORBIDDEN_MESSAGE = "URI forbid to be persisted!"; const std::string INVALID_MODE_MESSAGE = "Invalid operation mode!"; const std::string INVALID_PATH_MESSAGE = "Invalid path!"; @@ -40,8 +40,8 @@ bool CheckValidUri(const string &uriStr) LOGE("the URI is media URI"); return false; } - if (uriStr.find(REMOTE_SHARE_PATH_DIR) != string::npos) { - LOGE("the URI is distributed URI"); + if (uriStr.find(NETWORK_PARA) != string::npos) { + LOGE("the URI is not the current device URI"); return false; } return true; -- Gitee From cf319f3233c21a4ef163e679f53d95d263b45fcd Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 20:31:11 +0800 Subject: [PATCH 10/14] modify Signed-off-by: LVB8189 --- interfaces/innerkits/native/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/innerkits/native/BUILD.gn b/interfaces/innerkits/native/BUILD.gn index 55915f338..bc2f205ea 100644 --- a/interfaces/innerkits/native/BUILD.gn +++ b/interfaces/innerkits/native/BUILD.gn @@ -46,8 +46,8 @@ ohos_shared_library("fileshare_native") { sources = [ "../../common/src/json_utils.cpp", "../../common/src/sandbox_helper.cpp", - "file_share/src/file_share.cpp", "file_share/src/file_permission.cpp", + "file_share/src/file_share.cpp", ] public_configs = [ ":file_share_config" ] -- Gitee From 213ebd36a7252546a92660ca685c10c93030b59e Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 20:49:53 +0800 Subject: [PATCH 11/14] modify Signed-off-by: LVB8189 --- .../file_share/include/file_permission.h | 4 ++-- .../native/file_share/src/file_permission.cpp | 2 +- .../kits/js/file_share/grant_permissions.cpp | 16 ++------------ .../kits/js/file_share/grant_permissions.h | 5 ++--- .../file_share_native/file_share_test.cpp | 22 +++++++++---------- 5 files changed, 18 insertions(+), 31 deletions(-) diff --git a/interfaces/innerkits/native/file_share/include/file_permission.h b/interfaces/innerkits/native/file_share/include/file_permission.h index ae2f5bcd7..6d378809e 100644 --- a/interfaces/innerkits/native/file_share/include/file_permission.h +++ b/interfaces/innerkits/native/file_share/include/file_permission.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef _APP_FILE_SERVICE_FILE_PERMISSION_ -#define _APP_FILE_SERVICE_FILE_PERMISSION_ +#ifndef APP_FILE_SERVICE_FILE_PERMISSION +#define APP_FILE_SERVICE_FILE_PERMISSION #include #include diff --git a/interfaces/innerkits/native/file_share/src/file_permission.cpp b/interfaces/innerkits/native/file_share/src/file_permission.cpp index 823618277..492dd8584 100644 --- a/interfaces/innerkits/native/file_share/src/file_permission.cpp +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -30,7 +30,7 @@ const std::string FILE_SCHEME_PREFIX = "file://"; namespace { bool CheckValidUri(const string &uriStr) { - if(uriStr.find(FILE_SCHEME_PREFIX) != 0){ + if (uriStr.find(FILE_SCHEME_PREFIX) != 0) { LOGE("Incorrect URI format!"); return false; } diff --git a/interfaces/kits/js/file_share/grant_permissions.cpp b/interfaces/kits/js/file_share/grant_permissions.cpp index 5bb4f9a06..ace80f3d9 100644 --- a/interfaces/kits/js/file_share/grant_permissions.cpp +++ b/interfaces/kits/js/file_share/grant_permissions.cpp @@ -34,7 +34,7 @@ using namespace std; namespace { const std::string FILE_ACCESS_PERMISSION = "ohos.permission.FILE_ACCESS_PERSIST"; const std::string SET_SANDBOX_POLICY_PERMISSION = "ohos.permission.SET_SANDBOX_POLICY"; -const char *FULL_MOUNT_ENABLE_PARAMETER = "const.filemanager.full_mout.enable"; +const char *g_FULL_MOUNT_ENABLE_PARAMETER = "const.filemanager.full_mout.enable"; static bool IsSystemApp() { @@ -52,7 +52,7 @@ static bool CheckPermission(const string &permission) static bool CheckFileManagerFullMountEnable() { char value[] = "false"; - int retSystem = GetParameter(FULL_MOUNT_ENABLE_PARAMETER, "false", value, sizeof(value)); + int retSystem = GetParameter(g_FULL_MOUNT_ENABLE_PARAMETER, "false", value, sizeof(value)); if (retSystem > 0 && !strcmp(value, "true")) { LOGE("The full mount enable parameter is true"); return true; @@ -225,9 +225,6 @@ napi_value PersistPermission(napi_env env, napi_callback_info info) napi_value data = err.GetNapiErr(env); napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); - if (status != napi_ok) { - LOGE("Failed to set data property on Error"); - } return {env, data}; } return {env, err.GetNapiErr(env)}; @@ -277,9 +274,6 @@ napi_value RevokePermission(napi_env env, napi_callback_info info) napi_value data = err.GetNapiErr(env); napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); - if (status != napi_ok) { - LOGE("Failed to set data property on Error"); - } return {env, data}; } return {env, err.GetNapiErr(env)}; @@ -329,9 +323,6 @@ napi_value ActivatePermission(napi_env env, napi_callback_info info) napi_value data = err.GetNapiErr(env); napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); - if (status != napi_ok) { - LOGE("Failed to set data property on Error"); - } return {env, data}; } return {env, err.GetNapiErr(env)}; @@ -381,9 +372,6 @@ napi_value DeactivatePermission(napi_env env, napi_callback_info info) napi_value data = err.GetNapiErr(env); napi_status status = napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); - if (status != napi_ok) { - LOGE("Failed to set data property on Error"); - } return {env, data}; } return {env, err.GetNapiErr(env)}; diff --git a/interfaces/kits/js/file_share/grant_permissions.h b/interfaces/kits/js/file_share/grant_permissions.h index 7ff720659..c32c6c204 100644 --- a/interfaces/kits/js/file_share/grant_permissions.h +++ b/interfaces/kits/js/file_share/grant_permissions.h @@ -13,9 +13,8 @@ * limitations under the License. */ -#ifndef _GRANT_PERMISSIONS_H_ - -#define _GRANT_PERMISSIONS_H_ +#ifndef GRANT_PERMISSIONS_H +#define GRANT_PERMISSIONS_H #include diff --git a/test/unittest/file_share_native/file_share_test.cpp b/test/unittest/file_share_native/file_share_test.cpp index 6101dbd77..0af2942fb 100644 --- a/test/unittest/file_share_native/file_share_test.cpp +++ b/test/unittest/file_share_native/file_share_test.cpp @@ -38,7 +38,7 @@ using namespace OHOS::AppFileService; using namespace OHOS::Security::AccessToken; const int E_OK = 0; -const string bundleA = "com.example.filesharea"; +const string BUNDLE_A = "com.example.filesharea"; class FileShareTest : public testing::Test { public: @@ -426,7 +426,7 @@ HWTEST_F(FileShareTest, File_share_GetPhysicalPath_0006, testing::ext::TestSize. HWTEST_F(FileShareTest, GrantPermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin GrantPermission"; - string uri = "file://" + bundleA + "/data/test"; + string uri = "file://" + BUNDLE_A + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -449,7 +449,7 @@ HWTEST_F(FileShareTest, GrantPermission_test_0000, testing::ext::TestSize.Level1 HWTEST_F(FileShareTest, GrantPermission_test_0001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin GrantPermission_test_0001"; - string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string inexistentUri = "file://" + BUNDLE_A + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; @@ -475,7 +475,7 @@ HWTEST_F(FileShareTest, GrantPermission_test_0001, testing::ext::TestSize.Level1 HWTEST_F(FileShareTest, PersistPermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0000"; - string uri = "file://" + bundleA + "/data/test"; + string uri = "file://" + BUNDLE_A + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -498,7 +498,7 @@ HWTEST_F(FileShareTest, PersistPermission_test_0000, testing::ext::TestSize.Leve HWTEST_F(FileShareTest, PersistPermission_test_0001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0001"; - string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string inexistentUri = "file://" + BUNDLE_A + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; @@ -524,7 +524,7 @@ HWTEST_F(FileShareTest, PersistPermission_test_0001, testing::ext::TestSize.Leve HWTEST_F(FileShareTest, DesistPersistedPermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin DesistPersistedPermission_test_0000"; - string uri = "file://" + bundleA + "/data/test"; + string uri = "file://" + BUNDLE_A + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -547,7 +547,7 @@ HWTEST_F(FileShareTest, DesistPersistedPermission_test_0000, testing::ext::TestS HWTEST_F(FileShareTest, DesistPersistedPermission_test_0001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin DesistPersistedPermission_test_0001"; - string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string inexistentUri = "file://" + BUNDLE_A + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; @@ -573,7 +573,7 @@ HWTEST_F(FileShareTest, DesistPersistedPermission_test_0001, testing::ext::TestS HWTEST_F(FileShareTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0000"; - string uri = "file://" + bundleA + "/data/test"; + string uri = "file://" + BUNDLE_A + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -596,7 +596,7 @@ HWTEST_F(FileShareTest, ActivatePermission_test_0000, testing::ext::TestSize.Lev HWTEST_F(FileShareTest, ActivatePermission_test_0001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0001"; - string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string inexistentUri = "file://" + BUNDLE_A + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; @@ -622,7 +622,7 @@ HWTEST_F(FileShareTest, ActivatePermission_test_0001, testing::ext::TestSize.Lev HWTEST_F(FileShareTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0000"; - string uri = "file://" + bundleA + "/data/test"; + string uri = "file://" + BUNDLE_A + "/data/test"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; uriPolicyInfo.uri = uri; @@ -645,7 +645,7 @@ HWTEST_F(FileShareTest, DeactivatePermission_test_0000, testing::ext::TestSize.L HWTEST_F(FileShareTest, DeactivatePermission_test_0001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0001"; - string inexistentUri = "file://" + bundleA + "/data/storage/el2/base/files/inexistentTest.txt"; + string inexistentUri = "file://" + BUNDLE_A + "/data/storage/el2/base/files/inexistentTest.txt"; string mediaUri = "file://media/data/storage/el2/base"; std::vector uriPolicies; UriPolicyInfo uriPolicyInfo; -- Gitee From 575a096bab76ba861aa3d50e16104def2857d5d6 Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 21:04:36 +0800 Subject: [PATCH 12/14] modify Signed-off-by: LVB8189 --- interfaces/kits/js/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index 213f28874..ee1a7758b 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -61,8 +61,8 @@ ohos_shared_library("fileshare") { sources = [ "../../innerkits/native/file_share/src/file_permission.cpp", "file_share/fileshare_n_exporter.cpp", - "file_share/grant_uri_permission.cpp", "file_share/grant_permissions.cpp", + "file_share/grant_uri_permission.cpp", ] external_deps = [ -- Gitee From af8e3b979776b14882891d101e1f2ccf25cf572c Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 21:10:01 +0800 Subject: [PATCH 13/14] modify Signed-off-by: LVB8189 --- interfaces/kits/js/file_share/grant_permissions.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/interfaces/kits/js/file_share/grant_permissions.cpp b/interfaces/kits/js/file_share/grant_permissions.cpp index ace80f3d9..80ce020a1 100644 --- a/interfaces/kits/js/file_share/grant_permissions.cpp +++ b/interfaces/kits/js/file_share/grant_permissions.cpp @@ -34,7 +34,7 @@ using namespace std; namespace { const std::string FILE_ACCESS_PERMISSION = "ohos.permission.FILE_ACCESS_PERSIST"; const std::string SET_SANDBOX_POLICY_PERMISSION = "ohos.permission.SET_SANDBOX_POLICY"; -const char *g_FULL_MOUNT_ENABLE_PARAMETER = "const.filemanager.full_mout.enable"; +const char *g_fullMountEnableParameter = "const.filemanager.full_mout.enable"; static bool IsSystemApp() { @@ -52,7 +52,7 @@ static bool CheckPermission(const string &permission) static bool CheckFileManagerFullMountEnable() { char value[] = "false"; - int retSystem = GetParameter(g_FULL_MOUNT_ENABLE_PARAMETER, "false", value, sizeof(value)); + int retSystem = GetParameter(g_fullMountEnableParameter, "false", value, sizeof(value)); if (retSystem > 0 && !strcmp(value, "true")) { LOGE("The full mount enable parameter is true"); return true; -- Gitee From e6382be60c91d65d3a9fb71b20ce1664b4376402 Mon Sep 17 00:00:00 2001 From: LVB8189 Date: Sat, 2 Dec 2023 21:15:01 +0800 Subject: [PATCH 14/14] modify Signed-off-by: LVB8189 --- interfaces/kits/js/file_share/grant_permissions.cpp | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/interfaces/kits/js/file_share/grant_permissions.cpp b/interfaces/kits/js/file_share/grant_permissions.cpp index 80ce020a1..b0be83bc1 100644 --- a/interfaces/kits/js/file_share/grant_permissions.cpp +++ b/interfaces/kits/js/file_share/grant_permissions.cpp @@ -223,8 +223,7 @@ napi_value PersistPermission(napi_env env, napi_callback_info info) if (err) { if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = - napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); return {env, data}; } return {env, err.GetNapiErr(env)}; @@ -272,8 +271,7 @@ napi_value RevokePermission(napi_env env, napi_callback_info info) if (err) { if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = - napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); return {env, data}; } return {env, err.GetNapiErr(env)}; @@ -321,8 +319,7 @@ napi_value ActivatePermission(napi_env env, napi_callback_info info) if (err) { if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = - napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); return {env, data}; } return {env, err.GetNapiErr(env)}; @@ -370,8 +367,7 @@ napi_value DeactivatePermission(napi_env env, napi_callback_info info) if (err) { if (arg->errNo == EPERM) { napi_value data = err.GetNapiErr(env); - napi_status status = - napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + napi_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); return {env, data}; } return {env, err.GetNapiErr(env)}; -- Gitee