1 /*
2  * Copyright (c) 2022 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 
HandleEnvCleanup(void * data)30 void HandleEnvCleanup(void *data)
31 {
32     APP_LOGD("HandleEnvCleanup data null? %{public}d", data == nullptr);
33     if (data != nullptr) {
34         ZlibCallbackInfo *callbackInfo = static_cast<ZlibCallbackInfo *>(data);
35         callbackInfo->SetValid(false);
36     }
37 }
38 
ZlibCallbackInfo(napi_env env,napi_ref callback,napi_deferred deferred,bool isCallback)39 ZlibCallbackInfo::ZlibCallbackInfo(napi_env env, napi_ref callback, napi_deferred deferred, bool isCallback)
40     : env_(env), callback_(callback), deferred_(deferred), isCallBack_(isCallback)
41 {
42     napi_status status = napi_add_env_cleanup_hook(env_, HandleEnvCleanup, this);
43     APP_LOGD("ZlibCallbackInfo() status %{public}d", status);
44 }
45 
~ZlibCallbackInfo()46 ZlibCallbackInfo::~ZlibCallbackInfo() {}
47 
ExcuteWork(uv_loop_s * loop,uv_work_t * work)48 int32_t ZlibCallbackInfo::ExcuteWork(uv_loop_s* loop, uv_work_t* work)
49 {
50     int32_t ret = uv_queue_work(
51         loop, work, [](uv_work_t* work) {
52             APP_LOGD("ExcuteWork asyn work done");
53         },
54         [](uv_work_t* work, int status) {
55             if (work == nullptr) {
56                 return;
57             }
58             AsyncCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncCallbackInfo*>(work->data);
59             if (asyncCallbackInfo == nullptr) {
60                 return;
61             }
62             napi_handle_scope scope = nullptr;
63             napi_open_handle_scope(asyncCallbackInfo->env, &scope);
64             if (scope == nullptr) {
65                 return;
66             }
67             std::unique_ptr<AsyncCallbackInfo> callbackPtr {asyncCallbackInfo};
68             napi_value result[ARGS_ONE] = {0};
69             if (asyncCallbackInfo->deliverErrcode) {
70                 if (asyncCallbackInfo->callbackResult == ERR_OK) {
71                     CHKRV_SCOPE(asyncCallbackInfo->env, napi_get_null(asyncCallbackInfo->env, &result[0]), scope);
72                 } else {
73                     result[0] = BusinessError::CreateCommonError(asyncCallbackInfo->env,
74                         asyncCallbackInfo->callbackResult, "");
75                 }
76             } else {
77                 napi_create_int32(asyncCallbackInfo->env, asyncCallbackInfo->callbackResult, &result[0]);
78             }
79             if (asyncCallbackInfo->isCallBack) {
80                 napi_value callback = 0;
81                 napi_value placeHolder = nullptr;
82                 napi_get_reference_value(asyncCallbackInfo->env, asyncCallbackInfo->callback, &callback);
83                 CHKRV_SCOPE(asyncCallbackInfo->env, napi_call_function(asyncCallbackInfo->env, nullptr,
84                     callback, sizeof(result) / sizeof(result[0]), result, &placeHolder), scope);
85                 if (asyncCallbackInfo->callback != nullptr) {
86                     napi_delete_reference(asyncCallbackInfo->env, asyncCallbackInfo->callback);
87                 }
88             } else {
89                 if (asyncCallbackInfo->callbackResult == ERR_OK) {
90                     CHKRV_SCOPE(asyncCallbackInfo->env, napi_resolve_deferred(asyncCallbackInfo->env,
91                         asyncCallbackInfo->deferred, result[0]), scope);
92                 } else {
93                     CHKRV_SCOPE(asyncCallbackInfo->env, napi_reject_deferred(asyncCallbackInfo->env,
94                         asyncCallbackInfo->deferred, result[0]), scope);
95                 }
96             }
97             if (work != nullptr) {
98                 delete work;
99                 work = nullptr;
100             }
101             napi_status ret = napi_remove_env_cleanup_hook(asyncCallbackInfo->env, HandleEnvCleanup,
102                 asyncCallbackInfo->data);
103             APP_LOGD("rm env hook %{public}d", ret);
104             napi_close_handle_scope(asyncCallbackInfo->env, scope);
105         });
106     return ret;
107 }
108 
OnZipUnZipFinish(ErrCode result)109 void ZlibCallbackInfo::OnZipUnZipFinish(ErrCode result)
110 {
111     APP_LOGD("OnZipUnZipFinish ret %{public}d", result);
112     std::lock_guard<std::mutex> lock(validMutex_);
113     if (!valid_) {
114         APP_LOGE("module exported object is invalid");
115         return;
116     }
117 
118     // do callback or promise
119     uv_loop_s* loop = nullptr;
120     napi_get_uv_event_loop(env_, &loop);
121     if (loop == nullptr) {
122         APP_LOGE("loop is nullptr");
123         return;
124     }
125     uv_work_t* work = new (std::nothrow) uv_work_t;
126     if (work == nullptr) {
127         APP_LOGE("create work failed");
128         return;
129     }
130     ErrCode err = ERR_OK;
131     if (!deliverErrcode_) {
132         err = result == ERR_OK ? ERR_OK : ERROR_CODE_ERRNO;
133     } else {
134         err = CommonFunc::ConvertErrCode(result);
135     }
136 
137     AsyncCallbackInfo* asyncCallbackInfo = new (std::nothrow)AsyncCallbackInfo {
138         .env = env_,
139         .callback = callback_,
140         .deferred = deferred_,
141         .isCallBack = isCallBack_,
142         .callbackResult = err,
143         .deliverErrcode = deliverErrcode_,
144         .data = this,
145     };
146     std::unique_ptr<AsyncCallbackInfo> callbackPtr {asyncCallbackInfo};
147     if (asyncCallbackInfo == nullptr) {
148         delete work;
149         return;
150     }
151     work->data = reinterpret_cast<void*>(asyncCallbackInfo);
152     int32_t ret = ExcuteWork(loop, work);
153     if (ret != 0) {
154         if (asyncCallbackInfo != nullptr) {
155             delete asyncCallbackInfo;
156         }
157         if (work != nullptr) {
158             delete work;
159         }
160     }
161     callbackPtr.release();
162 }
163 
GetIsCallback() const164 bool ZlibCallbackInfo::GetIsCallback() const
165 {
166     return isCallBack_;
167 }
168 
SetIsCallback(bool isCallback)169 void ZlibCallbackInfo::SetIsCallback(bool isCallback)
170 {
171     isCallBack_ = isCallback;
172 }
173 
SetCallback(napi_ref callback)174 void ZlibCallbackInfo::SetCallback(napi_ref callback)
175 {
176     callback_ = callback;
177 }
178 
SetDeferred(napi_deferred deferred)179 void ZlibCallbackInfo::SetDeferred(napi_deferred deferred)
180 {
181     deferred_ = deferred;
182 }
183 
SetDeliverErrCode(bool isDeliverErrCode)184 void ZlibCallbackInfo::SetDeliverErrCode(bool isDeliverErrCode)
185 {
186     deliverErrcode_ = isDeliverErrCode;
187 }
188 
SetValid(bool valid)189 void ZlibCallbackInfo::SetValid(bool valid)
190 {
191     std::lock_guard<std::mutex> lock(validMutex_);
192     valid_ = valid;
193     if (!valid) {
194         env_ = nullptr;
195     }
196 }
197 }  // namespace LIBZIP
198 }  // namespace AppExecFwk
199 }  // namespace OHOS
200