From 6f75d73d677b054b11d7ea33f806e09c8f4c9655 Mon Sep 17 00:00:00 2001 From: atreeof_wind Date: Thu, 22 May 2025 15:44:42 +0800 Subject: [PATCH] [feat]:add fileshare ffi Signed-off-by: atreeof_wind --- bundle.json | 9 + interfaces/kits/cj/BUILD.gn | 49 +++ .../kits/cj/src/file_grant_permission_ffi.cpp | 306 ++++++++++++++++++ .../kits/cj/src/file_grant_permission_ffi.h | 39 +++ .../kits/cj/src/file_grant_permission_utils.h | 84 +++++ 5 files changed, 487 insertions(+) create mode 100644 interfaces/kits/cj/src/file_grant_permission_ffi.cpp create mode 100644 interfaces/kits/cj/src/file_grant_permission_ffi.h create mode 100644 interfaces/kits/cj/src/file_grant_permission_utils.h diff --git a/bundle.json b/bundle.json index 9d65cca9e..a7d492a6b 100644 --- a/bundle.json +++ b/bundle.json @@ -161,6 +161,15 @@ ], "header_base": "//foundation/filemanagement/app_file_service/interfaces//kits/cj/src" } + }, + { + "name": "//foundation/filemanagement/app_file_service/interfaces/kits/cj:cj_file_grant_permission_ffi", + "header": { + "header_files": [ + "file_grant_permission_ffi.h" + ], + "header_base": "//foundation/filemanagement/app_file_service/interfaces/kits/cj/src" + } } ], "test": [ diff --git a/interfaces/kits/cj/BUILD.gn b/interfaces/kits/cj/BUILD.gn index 1e2d4d25a..f6e2f76bf 100644 --- a/interfaces/kits/cj/BUILD.gn +++ b/interfaces/kits/cj/BUILD.gn @@ -76,3 +76,52 @@ ohos_shared_library("cj_file_fileuri_ffi") { part_name = "app_file_service" subsystem_name = "filemanagement" } + +ohos_shared_library("cj_file_grant_permission_ffi") { + branch_protector_ret = "pac_ret" + sanitize = { + integer_overflow = true + cfi = true + cfi_cross_dso = true + debug = false + } + + include_dirs = [ + "${app_file_service_path}/interfaces", + "${app_file_service_path}/interfaces/common/include", + "${app_file_service_path}/interfaces/innerkits/native/file_share/include", + ] + + sources = [ "src/file_grant_permission_ffi.cpp" ] + + deps = [ + "${app_file_service_path}/interfaces/innerkits/native:fileshare_native", + "${app_file_service_path}/interfaces/innerkits/native:fileuri_native", + ] + + external_deps = [ + "ability_runtime:abilitykit_native", + "ability_runtime:extensionkit_native", + "ability_runtime:uri_permission_mgr", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "file_api:filemgmt_libhilog", + "file_api:filemgmt_libn", + "file_api:remote_uri_native", + "hilog:libhilog", + "init:libbegetutil", + "ipc:ipc_core", + "napi:ace_napi", + "napi:cj_bind_ffi", + "napi:cj_bind_native", + ] + defines = [] + + innerapi_tags = [ "platformsdk" ] + part_name = "app_file_service" + subsystem_name = "filemanagement" +} diff --git a/interfaces/kits/cj/src/file_grant_permission_ffi.cpp b/interfaces/kits/cj/src/file_grant_permission_ffi.cpp new file mode 100644 index 000000000..92dbaa090 --- /dev/null +++ b/interfaces/kits/cj/src/file_grant_permission_ffi.cpp @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2025 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_grant_permission_ffi.h" + +#include "file_permission.h" +#include "macro.h" +#include "n_error.h" +#include "uv.h" + +using namespace OHOS::FFI; + +namespace OHOS { +namespace CJSystemapi { +namespace FileGrantPermission { + +using namespace OHOS::AppFileService; +using namespace OHOS::FileManagement::LibN; + +char* MallocCString(const std::string& origin) +{ + if (origin.empty()) { + return nullptr; + } + auto length = origin.length() + 1; + char* res = static_cast(malloc(sizeof(char) * length)); + if (res == nullptr) { + return nullptr; + } + return std::char_traits::copy(res, origin.c_str(), length); +} + +int ConvertUVCode2ErrorCode(int errCode) +{ + if (errCode >= 0) { + return errCode; + } + auto uvCode = string_view(uv_err_name(errCode)); + if (uvCode2ErrCodeTable.find(uvCode) != uvCode2ErrCodeTable.end()) { + return uvCode2ErrCodeTable.at(uvCode); + } + return UNKROWN_ERR; +} + +CJError ConvertError(int errCode) +{ + CJError err = { 0, "" }; + int genericCode = ConvertUVCode2ErrorCode(errCode); + auto it = errCodeTable.find(genericCode); + if (it != errCodeTable.end()) { + err.errorcode = it->second.first; + err.message = it->second.second; + } else { + err.errorcode = errCodeTable.at(UNKROWN_ERR).first; + err.message = errCodeTable.at(UNKROWN_ERR).second + ", errno is " + to_string(abs(errCode)); + } + return err; +} + +extern "C" { +CArrCPolicyErrorResult FfiOHOSFileGPPersistPermission(CArrCPolicyInfo policies, int32_t* code) +{ + CArrCPolicyErrorResult res = { nullptr, 0 }; + if (policies.size > MAX_ARRAY_SIZE) { + LOGE("The length of the array is extra-long"); + *code = E_PARAMS; + return res; + } + std::vector uriPolicies; + if (policies.head == nullptr) { + return res; + } + for (int i = 0; i < policies.size; i++) { + auto head = policies.head + i; + std::string uriStr(head->uri); + UriPolicyInfo uriPolicy { .uri = uriStr, .mode = head->mode }; + uriPolicies.emplace_back(uriPolicy); + } + + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Make_shared is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + arg->errNo = FilePermission::PersistPermission(uriPolicies, arg->errorResults); + CJError err = ConvertError(arg->errNo); + if (err.errorcode != 0) { + *code = err.errorcode; + res.size = static_cast(arg->errorResults.size()); + CPolicyErrorResult* retArrValue = + static_cast(malloc(sizeof(CPolicyErrorResult) * res.size)); + if (retArrValue == nullptr) { + LOGE("malloc is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + for (int i = 0; i < res.size; i++) { + retArrValue[i].uri = MallocCString(arg->errorResults[i].uri); + retArrValue[i].code = arg->errorResults[i].code; + retArrValue[i].message = MallocCString(arg->errorResults[i].message); + } + res.head = retArrValue; + } + return res; +} + +CArrCPolicyErrorResult FfiOHOSFileGPRevokePermission(CArrCPolicyInfo policies, int32_t* code) +{ + CArrCPolicyErrorResult res = { nullptr, 0 }; + if (policies.size > MAX_ARRAY_SIZE) { + LOGE("The length of the array is extra-long"); + *code = E_PARAMS; + return res; + } + std::vector uriPolicies; + if (policies.head == nullptr) { + return res; + } + for (int i = 0; i < policies.size; i++) { + auto head = policies.head + i; + std::string uriStr(head->uri); + UriPolicyInfo uriPolicy { .uri = uriStr, .mode = head->mode }; + uriPolicies.emplace_back(uriPolicy); + } + + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Make_shared is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + arg->errNo = FilePermission::RevokePermission(uriPolicies, arg->errorResults); + CJError err = ConvertError(arg->errNo); + if (arg->errNo != 0) { + *code = err.errorcode; + res.size = static_cast(arg->errorResults.size()); + CPolicyErrorResult* retArrValue = + static_cast(malloc(sizeof(CPolicyErrorResult) * res.size)); + if (retArrValue == nullptr) { + LOGE("malloc is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + for (int i = 0; i < res.size; i++) { + retArrValue[i].uri = MallocCString(arg->errorResults[i].uri); + retArrValue[i].code = arg->errorResults[i].code; + retArrValue[i].message = MallocCString(arg->errorResults[i].message); + } + } + return res; +} + +CArrCPolicyErrorResult FfiOHOSFileGPActivatePermission(CArrCPolicyInfo policies, int32_t* code) +{ + CArrCPolicyErrorResult res = { nullptr, 0 }; + if (policies.size > MAX_ARRAY_SIZE) { + LOGE("The length of the array is extra-long"); + *code = E_PARAMS; + return res; + } + std::vector uriPolicies; + if (policies.head == nullptr) { + return res; + } + for (int i = 0; i < policies.size; i++) { + auto head = policies.head + i; + std::string uriStr(head->uri); + UriPolicyInfo uriPolicy { .uri = uriStr, .mode = head->mode }; + uriPolicies.emplace_back(uriPolicy); + } + + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Make_shared is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + arg->errNo = FilePermission::ActivatePermission(uriPolicies, arg->errorResults); + CJError err = ConvertError(arg->errNo); + if (arg->errNo != 0) { + *code = err.errorcode; + res.size = static_cast(arg->errorResults.size()); + CPolicyErrorResult* retArrValue = + static_cast(malloc(sizeof(CPolicyErrorResult) * res.size)); + if (retArrValue == nullptr) { + LOGE("malloc is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + for (int i = 0; i < res.size; i++) { + retArrValue[i].uri = MallocCString(arg->errorResults[i].uri); + retArrValue[i].code = arg->errorResults[i].code; + retArrValue[i].message = MallocCString(arg->errorResults[i].message); + } + } + return res; +} + +CArrCPolicyErrorResult FfiOHOSFileGPDeactivatePermission(CArrCPolicyInfo policies, int32_t* code) +{ + CArrCPolicyErrorResult res = { nullptr, 0 }; + if (policies.size > MAX_ARRAY_SIZE) { + LOGE("The length of the array is extra-long"); + *code = E_PARAMS; + return res; + } + std::vector uriPolicies; + if (policies.head == nullptr) { + return res; + } + for (int i = 0; i < policies.size; i++) { + auto head = policies.head + i; + std::string uriStr(head->uri); + UriPolicyInfo uriPolicy { .uri = uriStr, .mode = head->mode }; + uriPolicies.emplace_back(uriPolicy); + } + + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Make_shared is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + arg->errNo = FilePermission::DeactivatePermission(uriPolicies, arg->errorResults); + CJError err = ConvertError(arg->errNo); + if (arg->errNo != 0) { + *code = err.errorcode; + res.size = static_cast(arg->errorResults.size()); + CPolicyErrorResult* retArrValue = + static_cast(malloc(sizeof(CPolicyErrorResult) * res.size)); + if (retArrValue == nullptr) { + LOGE("malloc is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + for (int i = 0; i < res.size; i++) { + retArrValue[i].uri = MallocCString(arg->errorResults[i].uri); + retArrValue[i].code = arg->errorResults[i].code; + retArrValue[i].message = MallocCString(arg->errorResults[i].message); + } + } + return res; +} + +CArrBool FfiOHOSFileGPCheckPersistentPermission(CArrCPolicyInfo policies, int32_t* code) +{ + CArrBool res = { nullptr, 0 }; + if (policies.size > MAX_ARRAY_SIZE) { + LOGE("The length of the array is extra-long"); + *code = E_PARAMS; + return res; + } + std::vector uriPolicies; + if (policies.head == nullptr) { + return res; + } + for (int i = 0; i < policies.size; i++) { + auto head = policies.head + i; + + std::string uriStr(head->uri); + UriPolicyInfo uriPolicy { .uri = uriStr, .mode = head->mode }; + uriPolicies.emplace_back(uriPolicy); + } + + shared_ptr arg = make_shared(); + if (arg == nullptr) { + LOGE("Make_shared is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + arg->errNo = FilePermission::CheckPersistentPermission(uriPolicies, arg->resultData); + CJError err = ConvertError(arg->errNo); + if (err.errorcode != 0) { + *code = err.errorcode; + } else { + res.size = static_cast(arg->resultData.size()); + bool* retArrValue = static_cast(malloc(sizeof(bool) * res.size)); + if (retArrValue == nullptr) { + LOGE("malloc is failed"); + *code = E_UNKNOWN_ERROR; + return res; + } + for (int i = 0; i < res.size; i++) { + retArrValue[i] = arg->resultData[i]; + } + res.head = retArrValue; + } + return res; +} +} +} // namespace FileGrantPermission +} // namespace CJSystemapi +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/cj/src/file_grant_permission_ffi.h b/interfaces/kits/cj/src/file_grant_permission_ffi.h new file mode 100644 index 000000000..34cfaadfa --- /dev/null +++ b/interfaces/kits/cj/src/file_grant_permission_ffi.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 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 OHOS_FILE_GRANT_PERMISSION_FFI_H +#define OHOS_FILE_GRANT_PERMISSION_FFI_H + +#include + +#include "file_grant_permission_utils.h" +#include "native/ffi_remote_data.h" + +namespace OHOS { +namespace CJSystemapi { +namespace FileGrantPermission { + +extern "C" { +FFI_EXPORT CArrCPolicyErrorResult FfiOHOSFileGPPersistPermission(CArrCPolicyInfo policies, int32_t* code); +FFI_EXPORT CArrCPolicyErrorResult FfiOHOSFileGPRevokePermission(CArrCPolicyInfo policies, int32_t* code); +FFI_EXPORT CArrCPolicyErrorResult FfiOHOSFileGPActivatePermission(CArrCPolicyInfo policies, int32_t* code); +FFI_EXPORT CArrCPolicyErrorResult FfiOHOSFileGPDeactivatePermission(CArrCPolicyInfo policies, int32_t* code); +FFI_EXPORT CArrBool FfiOHOSFileGPCheckPersistentPermission(CArrCPolicyInfo policies, int32_t* code); +} +} // namespace FileGrantPermission +} // namespace CJSystemapi +} // namespace OHOS + +#endif // OHOS_FILE_GRANT_PERMISSION_FFI_H \ No newline at end of file diff --git a/interfaces/kits/cj/src/file_grant_permission_utils.h b/interfaces/kits/cj/src/file_grant_permission_utils.h new file mode 100644 index 000000000..d90203f4d --- /dev/null +++ b/interfaces/kits/cj/src/file_grant_permission_utils.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2025 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 OHOS_FILE_GRANT_PERMISSION_UTILS_H +#define OHOS_FILE_GRANT_PERMISSION_UTILS_H + +#include +#include +#include +#include + +#include "cj_ffi/cj_common_ffi.h" +#include "file_permission.h" + +namespace OHOS { +namespace CJSystemapi { +namespace FileGrantPermission { + +using namespace std; + +struct CPolicyInfo { + char* uri; + uint32_t mode; +}; + +struct CArrCPolicyInfo { + CPolicyInfo* head; + int64_t size; +}; + +struct PolicyErrorArgs { + deque errorResults; + int32_t errNo = 0; + ~PolicyErrorArgs() = default; +}; + +struct PolicyInfoResultArgs { + vector resultData; + int32_t errNo = 0; + ~PolicyInfoResultArgs() = default; +}; + +struct CPolicyErrorResult { + char* uri; + int32_t code; + char* message; +}; + +struct CArrCPolicyErrorResult { + CPolicyErrorResult* head; + int64_t size; +}; + +struct CArrBool { + bool* head; + int64_t size; +}; + +struct CJError { + int32_t errorcode; + std::string message; +}; + +enum CommonErrCode { + E_UNKNOWN_ERROR = 13900042, + E_PARAMS = 401, +}; + +} // namespace FileGrantPermission +} // namespace CJSystemapi +} // namespace OHOS +#endif // OHOS_FILE_GRANT_PERMISSION_UTILS_H \ No newline at end of file -- Gitee