diff --git a/interfaces/innerkits/native/BUILD.gn b/interfaces/innerkits/native/BUILD.gn index a66a94ad76c021a9d1f327493df879be79fc3fcc..bc2f205eab24e14dde0066f63b08239cbf1c51a1 100644 --- a/interfaces/innerkits/native/BUILD.gn +++ b/interfaces/innerkits/native/BUILD.gn @@ -46,6 +46,7 @@ ohos_shared_library("fileshare_native") { sources = [ "../../common/src/json_utils.cpp", "../../common/src/sandbox_helper.cpp", + "file_share/src/file_permission.cpp", "file_share/src/file_share.cpp", ] 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 0000000000000000000000000000000000000000..6d378809eefc9c0af0f06ba95cd171c55ce027d4 --- /dev/null +++ b/interfaces/innerkits/native/file_share/include/file_permission.h @@ -0,0 +1,81 @@ +/* + * 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 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 PathPolicyInfo { + string path = ""; + uint32_t mode = OperationMode::READ_MODE; +}; + +struct PolicyErrorResult { + string uri = ""; + PolicyErrorCode code = PolicyErrorCode::PERSISTENCE_FORBIDDEN; + string message = ""; +}; + +class FilePermission { +public: + 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 &pathPolicies, + deque &errorResults); + static void GetPathPolicyInfoFromUriPolicyInfo(const vector &uriPolicies, + deque &errorResults, + vector &pathPolicies); +}; +} // 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 0000000000000000000000000000000000000000..492dd8584c7915871355e0c00f39854c5d267f94 --- /dev/null +++ b/interfaces/innerkits/native/file_share/src/file_permission.cpp @@ -0,0 +1,173 @@ +/* + * 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 "log.h" +#include "uri.h" + +namespace OHOS { +namespace AppFileService { +const std::string MEDIA_AUTHORITY = "media"; +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!"; +const std::string FILE_SCHEME_PREFIX = "file://"; + +namespace { +bool CheckValidUri(const string &uriStr) +{ + if (uriStr.find(FILE_SCHEME_PREFIX) != 0) { + LOGE("Incorrect URI format!"); + return false; + } + Uri uri(uriStr); + std::string bundleName = uri.GetAuthority(); + if (bundleName == MEDIA_AUTHORITY) { + LOGE("the URI is media URI"); + return false; + } + if (uriStr.find(NETWORK_PARA) != string::npos) { + LOGE("the URI is not the current device URI"); + return false; + } + return true; +} +} // namespace + +void FilePermission::GetErrorResults(const vector &resultCodes, + 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 = {uri.ToString(), PolicyErrorCode::PERSISTENCE_FORBIDDEN, PERSISTENCE_FORBIDDEN_MESSAGE}; + errorResults.emplace_back(result); + break; + case static_cast(PolicyErrorCode::INVALID_MODE): + result = {uri.ToString(), PolicyErrorCode::INVALID_MODE, INVALID_MODE_MESSAGE}; + errorResults.emplace_back(result); + break; + case static_cast(PolicyErrorCode::INVALID_PATH): + result = {uri.ToString(), PolicyErrorCode::INVALID_PATH, INVALID_PATH_MESSAGE}; + errorResults.emplace_back(result); + break; + default: + break; + } + } +} + +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 correct uri!"); + PolicyErrorResult result = {uriPolicy.uri, PolicyErrorCode::INVALID_PATH, INVALID_PATH_MESSAGE}; + errorResults.emplace_back(result); + } else { + PathPolicyInfo policyInfo = {path, uriPolicy.mode}; + pathPolicies.emplace_back(policyInfo); + } + } +} + +int32_t FilePermission::GrantPermission(uint32_t tokenId, const vector &uriPolicies, uint32_t policyFlag) +{ + vector pathPolicies; + deque errorResults; + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); + // SandboxManager interface call + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("GrantPermission success"); + return 0; +} + +int32_t FilePermission::PersistPermission(const vector &uriPolicies, + deque &errorResults) +{ + vector pathPolicies; + vector resultCodes; + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); + // SandboxManager interface call + GetErrorResults(resultCodes, pathPolicies, errorResults); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("PersistPermission success"); + return 0; +} + +int32_t FilePermission::RevokePermission(const vector &uriPolicies, + deque &errorResults) +{ + vector pathPolicies; + vector resultCodes; + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); + // SandboxManager interface call + GetErrorResults(resultCodes, pathPolicies, errorResults); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("RevokePermission success"); + return 0; +} + +int32_t FilePermission::ActivatePermission(const vector &uriPolicies, + deque &errorResults) +{ + vector pathPolicies; + vector resultCodes; + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); + // SandboxManager interface call + GetErrorResults(resultCodes, pathPolicies, errorResults); + if (!errorResults.empty()) { + LOGE("There are some URI operations that fail"); + return EPERM; + } + LOGD("ActivatePermission success"); + return 0; +} + +int32_t FilePermission::DeactivatePermission(const vector &uriPolicies, + deque &errorResults) +{ + vector pathPolicies; + vector resultCodes; + GetPathPolicyInfoFromUriPolicyInfo(uriPolicies, errorResults, pathPolicies); + // SandboxManager interface call + GetErrorResults(resultCodes, pathPolicies, 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 4aa1ffc53225ff8862bac7968057fe13032aed45..ee1a7758bfeacf36173dac4576abcf81e97d47f1 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -55,10 +55,13 @@ ohos_shared_library("fileshare") { include_dirs = [ ".", "../../common/include", + "${app_file_service_path}/interfaces/innerkits/native/file_share/include", ] sources = [ + "../../innerkits/native/file_share/src/file_permission.cpp", "file_share/fileshare_n_exporter.cpp", + "file_share/grant_permissions.cpp", "file_share/grant_uri_permission.cpp", ] @@ -67,6 +70,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", @@ -76,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 a293e305735f287d0b805d6dabd9d802aa1b7654..f9eceee4e3a84fd1a95ec86ea9075a0a41f8c459 100644 --- a/interfaces/kits/js/file_share/fileshare_n_exporter.cpp +++ b/interfaces/kits/js/file_share/fileshare_n_exporter.cpp @@ -13,23 +13,184 @@ * limitations under the License. */ #include "fileshare_n_exporter.h" +#include "file_permission.h" +#include "grant_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) { + InitOperationMode(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 InitOperationMode(napi_env env, napi_value exports) +{ + char propertyName[] = "OperationMode"; + napi_property_descriptor desc[] = { + DECLARE_NAPI_STATIC_PROPERTY("READ_MODE", + NVal::CreateUint32(env, static_cast(OperationMode::READ_MODE)).val_), + DECLARE_NAPI_STATIC_PROPERTY("WRITE_MODE", + 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 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 OperationMode"); + return; + } + status = napi_set_named_property(env, exports, propertyName, obj); + if (status != napi_ok) { + HILOGE("Failed to set direction property at initializing OperationMode"); + return; + } +} + +void InitPolicyFlag(napi_env env, napi_value exports) +{ + char propertyName[] = "PolicyFlag"; + napi_property_descriptor desc[] = { + 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); + 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( + "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", + 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::PERSISTENCE_FORBIDDEN)).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("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, + 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 556f62a8ad198250938e575b3630e2a30a6e3b8b..3b1a8200454f1c03a04461a71f31f0856207ae4d 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 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); +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_permissions.cpp b/interfaces/kits/js/file_share/grant_permissions.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b0be83bc188b7e699e5f413702a58a906802036a --- /dev/null +++ b/interfaces/kits/js/file_share/grant_permissions.cpp @@ -0,0 +1,383 @@ +/* + * 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_permissions.h" + +#include +#include + +#include "access_token.h" +#include "accesstoken_kit.h" +#include "ipc_skeleton.h" +#include "log.h" +#include "n_napi.h" +#include "parameter.h" +#include "tokenid_kit.h" + +namespace OHOS { +namespace AppFileService { +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 *g_fullMountEnableParameter = "const.filemanager.full_mout.enable"; + +static bool IsSystemApp() +{ + uint32_t fullTokenId = OHOS::IPCSkeleton::GetCallingFullTokenID(); + return Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(fullTokenId); +} + +static bool CheckPermission(const string &permission) +{ + Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID(); + return Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission) == + Security::AccessToken::PermissionState::PERMISSION_GRANTED; +} + +static bool CheckFileManagerFullMountEnable() +{ + char value[] = "false"; + 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; + } + LOGD("The full mount enable parameter is false"); + return false; +} +} // 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, "operationMode", &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) +{ + 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!"); + 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; + } + 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) { + 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) { + 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) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this api"); + 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("PersistPermission Number of arguments unmatched"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::vector uriPolicies; + 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) { + 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_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + 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) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this api"); + NError(E_DEVICENOTSUPPORT).ThrowErr(env); + return nullptr; + } + if (!CheckPermission(FILE_ACCESS_PERMISSION)) { + LOGE("RevokePermission has not ohos permission!"); + 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; + 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) { + 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_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + 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) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this api"); + 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"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::vector uriPolicies; + 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) { + 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_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + 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) +{ + if (!CheckFileManagerFullMountEnable()) { + LOGE("The device doesn't support this api"); + 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"); + NError(E_PARAMS).ThrowErr(env); + return nullptr; + } + std::vector uriPolicies; + 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) { + 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_set_named_property(env, data, FILEIO_TAG_ERR_DATA.c_str(), GetErrData(env, arg->errorResults)); + 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_permissions.h b/interfaces/kits/js/file_share/grant_permissions.h new file mode 100644 index 0000000000000000000000000000000000000000..c32c6c20496e646716246fd8793b13cf650a21a2 --- /dev/null +++ b/interfaces/kits/js/file_share/grant_permissions.h @@ -0,0 +1,41 @@ +/* + * 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_PERMISSIONS_H +#define GRANT_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_PERMISSIONS_H_ diff --git a/test/unittest/file_share_native/file_share_test.cpp b/test/unittest/file_share_native/file_share_test.cpp index 9b2ac0c6f4b0c13bafb33d87d16ab23b04c4b4b9..0af2942fbd4c54dc67fe3617ed170f5323200c62 100644 --- a/test/unittest/file_share_native/file_share_test.cpp +++ b/test/unittest/file_share_native/file_share_test.cpp @@ -16,6 +16,7 @@ #include #include #include + #include #include #include @@ -24,389 +25,638 @@ #include "access_token_error.h" #include "accesstoken_kit.h" +#include "file_permission.h" #include "file_share.h" #include "ipc_skeleton.h" +#include "log.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"; - } - - /** - * @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"; - } -} \ No newline at end of file +using namespace std; +using namespace OHOS::AppFileService; +using namespace OHOS::Security::AccessToken; + +const int E_OK = 0; +const string BUNDLE_A = "com.example.filesharea"; + +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"; +} + +/** + * @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(FileShareTest, GrantPermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin GrantPermission"; + string uri = "file://" + BUNDLE_A + "/data/test"; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uint32_t policyFlag = PolicyFlag::ALLOW_PERSISTENCE; + uriPolicies.emplace_back(uriPolicyInfo); + int32_t ret = FilePermission::GrantPermission(0, uriPolicies, policyFlag); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, GrantPermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin GrantPermission_test_0001"; + 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; + uriPolicyInfo.uri = inexistentUri; + 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(0, uriPolicies, policyFlag); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, PersistPermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0000"; + string uri = "file://" + BUNDLE_A + "/data/test"; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + deque errorResults; + int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, PersistPermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin PersistPermission_test_0001"; + 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; + uriPolicyInfo.uri = inexistentUri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + deque errorResults; + int32_t ret = FilePermission::PersistPermission(uriPolicies, errorResults); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, DesistPersistedPermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin DesistPersistedPermission_test_0000"; + string uri = "file://" + BUNDLE_A + "/data/test"; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + deque errorResults; + int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, DesistPersistedPermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin DesistPersistedPermission_test_0001"; + 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; + uriPolicyInfo.uri = inexistentUri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + deque errorResults; + int32_t ret = FilePermission::RevokePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, ActivatePermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0000"; + string uri = "file://" + BUNDLE_A + "/data/test"; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + deque errorResults; + int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, ActivatePermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin ActivatePermission_test_0001"; + 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; + uriPolicyInfo.uri = inexistentUri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + deque errorResults; + int32_t ret = FilePermission::ActivatePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, EPERM); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, DeactivatePermission_test_0000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0000"; + string uri = "file://" + BUNDLE_A + "/data/test"; + std::vector uriPolicies; + UriPolicyInfo uriPolicyInfo; + uriPolicyInfo.uri = uri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + deque errorResults; + int32_t ret = FilePermission::DeactivatePermission(uriPolicies, errorResults); + EXPECT_EQ(ret, 0); + GTEST_LOG_(INFO) << "FileShareTest-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(FileShareTest, DeactivatePermission_test_0001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "FileShareTest-begin DeactivatePermission_test_0001"; + 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; + uriPolicyInfo.uri = inexistentUri; + uriPolicyInfo.mode = OperationMode::READ_MODE | OperationMode::WRITE_MODE; + uriPolicies.emplace_back(uriPolicyInfo); + uriPolicyInfo.uri = mediaUri; + uriPolicies.emplace_back(uriPolicyInfo); + 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