1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "zlib_callback_info.h"
17
18 #include "app_log_wrapper.h"
19 #include "common_func.h"
20 #include "business_error.h"
21 #include "node_api.h"
22
23 namespace OHOS {
24 namespace AppExecFwk {
25 namespace LIBZIP {
26 namespace {
27 constexpr size_t ARGS_ONE = 1;
28 }
29
30 static std::mutex callbackMutex;
31 static std::set<void *> callbackInfos;
32
HandleEnvCleanup(void * data)33 void HandleEnvCleanup(void *data)
34 {
35 APP_LOGI("on hook %{public}d", data == nullptr);
36 std::lock_guard<std::mutex> callbackLock(callbackMutex);
37 auto it = callbackInfos.find(data);
38 if (it == callbackInfos.end()) {
39 APP_LOGI("ZlibCallbackInfo destroyed");
40 return;
41 }
42 if (data != nullptr) {
43 ZlibCallbackInfo *callbackInfo = static_cast<ZlibCallbackInfo *>(data);
44 callbackInfo->SetValid(false);
45 }
46 }
47
ZlibCallbackInfo(napi_env env,napi_ref callback,napi_deferred deferred,bool isCallback)48 ZlibCallbackInfo::ZlibCallbackInfo(napi_env env, napi_ref callback, napi_deferred deferred, bool isCallback)
49 : env_(env), callback_(callback), deferred_(deferred), isCallBack_(isCallback)
50 {
51 napi_status status = napi_add_env_cleanup_hook(env_, HandleEnvCleanup, this);
52 APP_LOGI("add hook %{public}d", status);
53 std::lock_guard<std::mutex> callbackLock(callbackMutex);
54 callbackInfos.insert(this);
55 }
56
~ZlibCallbackInfo()57 ZlibCallbackInfo::~ZlibCallbackInfo()
58 {
59 APP_LOGI("~");
60 std::lock_guard<std::mutex> callbackLock(callbackMutex);
61 callbackInfos.erase(this);
62 }
63
ExcuteWork(uv_loop_s * loop,uv_work_t * work)64 int32_t ZlibCallbackInfo::ExcuteWork(uv_loop_s* loop, uv_work_t* work)
65 {
66 int32_t ret = uv_queue_work(
67 loop, work, [](uv_work_t* work) {
68 APP_LOGD("ExcuteWork asyn work done");
69 },
70 [](uv_work_t* work, int status) {
71 if (work == nullptr) {
72 APP_LOGE("work null");
73 return;
74 }
75 AsyncCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncCallbackInfo*>(work->data);
76 if (asyncCallbackInfo == nullptr) {
77 APP_LOGE("asyncCallbackInfo null");
78 return;
79 }
80 napi_handle_scope scope = nullptr;
81 napi_open_handle_scope(asyncCallbackInfo->env, &scope);
82 if (scope == nullptr) {
83 APP_LOGE("scope null");
84 return;
85 }
86 std::unique_ptr<AsyncCallbackInfo> callbackPtr {asyncCallbackInfo};
87 napi_value result[ARGS_ONE] = {0};
88 if (asyncCallbackInfo->deliverErrcode) {
89 if (asyncCallbackInfo->callbackResult == ERR_OK) {
90 CHKRV_SCOPE(asyncCallbackInfo->env, napi_get_null(asyncCallbackInfo->env, &result[0]), scope);
91 } else {
92 result[0] = BusinessError::CreateCommonError(asyncCallbackInfo->env,
93 asyncCallbackInfo->callbackResult, "");
94 }
95 } else {
96 napi_create_int32(asyncCallbackInfo->env, asyncCallbackInfo->callbackResult, &result[0]);
97 }
98 if (asyncCallbackInfo->isCallBack) {
99 napi_value callback = 0;
100 napi_value placeHolder = nullptr;
101 napi_get_reference_value(asyncCallbackInfo->env, asyncCallbackInfo->callback, &callback);
102 CHKRV_SCOPE(asyncCallbackInfo->env, napi_call_function(asyncCallbackInfo->env, nullptr,
103 callback, sizeof(result) / sizeof(result[0]), result, &placeHolder), scope);
104 if (asyncCallbackInfo->callback != nullptr) {
105 napi_delete_reference(asyncCallbackInfo->env, asyncCallbackInfo->callback);
106 }
107 } else {
108 if (asyncCallbackInfo->callbackResult == ERR_OK) {
109 CHKRV_SCOPE(asyncCallbackInfo->env, napi_resolve_deferred(asyncCallbackInfo->env,
110 asyncCallbackInfo->deferred, result[0]), scope);
111 } else {
112 CHKRV_SCOPE(asyncCallbackInfo->env, napi_reject_deferred(asyncCallbackInfo->env,
113 asyncCallbackInfo->deferred, result[0]), scope);
114 }
115 }
116 if (work != nullptr) {
117 delete work;
118 work = nullptr;
119 }
120 napi_status ret = napi_remove_env_cleanup_hook(asyncCallbackInfo->env, HandleEnvCleanup,
121 asyncCallbackInfo->data);
122 APP_LOGI("rm hook %{public}d", ret);
123 napi_close_handle_scope(asyncCallbackInfo->env, scope);
124 });
125 return ret;
126 }
127
OnZipUnZipFinish(ErrCode result)128 void ZlibCallbackInfo::OnZipUnZipFinish(ErrCode result)
129 {
130 APP_LOGI("finish %{public}d", result);
131 std::lock_guard<std::mutex> lock(validMutex_);
132 if (!valid_) {
133 APP_LOGE("module exported object is invalid");
134 return;
135 }
136
137 // do callback or promise
138 uv_loop_s* loop = nullptr;
139 napi_get_uv_event_loop(env_, &loop);
140 if (loop == nullptr) {
141 APP_LOGE("loop is nullptr");
142 return;
143 }
144 uv_work_t* work = new (std::nothrow) uv_work_t;
145 if (work == nullptr) {
146 APP_LOGE("create work failed");
147 return;
148 }
149 ErrCode err = ERR_OK;
150 if (!deliverErrcode_) {
151 err = result == ERR_OK ? ERR_OK : ERROR_CODE_ERRNO;
152 } else {
153 err = CommonFunc::ConvertErrCode(result);
154 }
155
156 AsyncCallbackInfo* asyncCallbackInfo = new (std::nothrow)AsyncCallbackInfo {
157 .env = env_,
158 .callback = callback_,
159 .deferred = deferred_,
160 .isCallBack = isCallBack_,
161 .callbackResult = err,
162 .deliverErrcode = deliverErrcode_,
163 .data = this,
164 };
165 std::unique_ptr<AsyncCallbackInfo> callbackPtr {asyncCallbackInfo};
166 if (asyncCallbackInfo == nullptr) {
167 delete work;
168 return;
169 }
170 work->data = reinterpret_cast<void*>(asyncCallbackInfo);
171 int32_t ret = ExcuteWork(loop, work);
172 if (ret != 0) {
173 if (asyncCallbackInfo != nullptr) {
174 delete asyncCallbackInfo;
175 }
176 if (work != nullptr) {
177 delete work;
178 }
179 }
180 callbackPtr.release();
181 }
182
DoTask(const OHOS::AppExecFwk::InnerEvent::Callback & task)183 void ZlibCallbackInfo::DoTask(const OHOS::AppExecFwk::InnerEvent::Callback& task)
184 {
185 PostTask(task);
186 }
187
GetIsCallback() const188 bool ZlibCallbackInfo::GetIsCallback() const
189 {
190 return isCallBack_;
191 }
192
SetIsCallback(bool isCallback)193 void ZlibCallbackInfo::SetIsCallback(bool isCallback)
194 {
195 isCallBack_ = isCallback;
196 }
197
SetCallback(napi_ref callback)198 void ZlibCallbackInfo::SetCallback(napi_ref callback)
199 {
200 callback_ = callback;
201 }
202
SetDeferred(napi_deferred deferred)203 void ZlibCallbackInfo::SetDeferred(napi_deferred deferred)
204 {
205 deferred_ = deferred;
206 }
207
SetDeliverErrCode(bool isDeliverErrCode)208 void ZlibCallbackInfo::SetDeliverErrCode(bool isDeliverErrCode)
209 {
210 deliverErrcode_ = isDeliverErrCode;
211 }
212
SetValid(bool valid)213 void ZlibCallbackInfo::SetValid(bool valid)
214 {
215 std::lock_guard<std::mutex> lock(validMutex_);
216 valid_ = valid;
217 if (!valid) {
218 env_ = nullptr;
219 }
220 }
221 } // namespace LIBZIP
222 } // namespace AppExecFwk
223 } // namespace OHOS
224