1 /*
2 * Copyright (c) 2024 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 "zip_n_exporter.h"
17
18 #include <cstdio>
19 #include <cstdlib>
20 #include <cstring>
21 #include <memory>
22 #include <sstream>
23 #include <string>
24 #include <tuple>
25
26 #include "common/common_func.h"
27 #include "common/napi_async_work_callback.h"
28 #include "common/napi_async_work_promise.h"
29 #include "common/napi_class.h"
30 #include "common/napi_func_arg.h"
31 #include "common/napi_business_error.h"
32 #include "securec.h"
33 #include "zip_entity.h"
34 #include "zlib.h"
35
36 namespace OHOS {
37 namespace AppExecFwk {
38 namespace LIBZIP {
39 static constexpr int32_t ERROR_CODE = -5;
40 static constexpr int32_t MIN_BITS = 0;
41 static constexpr int32_t MAX_BITS = 16;
42 struct AsyncZipArg {
43 const char *zliVersion = nullptr;
44 const char *zErrorMsg = nullptr;
45 uLong zlibCompileFlags = 0;
46 int32_t errCode = 0;
47 uint32_t pending = 0U;
48 int32_t bits = 0;
49 uLong destLen = 0U;
50 int32_t level = 0;
51 uLong sourceLen = 0U;
52 uInt dictLength = 0U;
53 int32_t method = 0;
54 int32_t windowBits = 0;
55 int32_t memLevel = 0;
56 int32_t strategy = 0;
57
58 AsyncZipArg() = default;
59 ~AsyncZipArg() = default;
60 };
61
62 struct InOutDesc {
63 napi_env env = nullptr;
64 napi_value func = nullptr;
65 napi_value desc = nullptr;
66
InOutDescOHOS::AppExecFwk::LIBZIP::InOutDesc67 InOutDesc(napi_env env, napi_value func, napi_value desc) : env(env), func(func), desc(desc) {};
68 ~InOutDesc() = default;
69 };
70
ZipOutputInfo(napi_env env,std::shared_ptr<AsyncZipArg> arg)71 static NapiValue ZipOutputInfo(napi_env env, std::shared_ptr<AsyncZipArg> arg)
72 {
73 NapiValue obj = NapiValue::CreateObject(env);
74 obj.AddProp({
75 NapiValue::DeclareNapiProperty("status", NapiValue::CreateInt32(env, arg->errCode).val_),
76 NapiValue::DeclareNapiProperty(
77 "destLen", NapiValue::CreateInt64(env, static_cast<int64_t>(arg->destLen)).val_),
78 });
79 return {obj};
80 }
81
DecompressionOutputInfo(napi_env env,std::shared_ptr<AsyncZipArg> arg)82 static NapiValue DecompressionOutputInfo(napi_env env, std::shared_ptr<AsyncZipArg> arg)
83 {
84 NapiValue obj = NapiValue::CreateObject(env);
85 obj.AddProp({
86 NapiValue::DeclareNapiProperty("status", NapiValue::CreateInt32(env, arg->errCode).val_),
87 NapiValue::DeclareNapiProperty(
88 "destLength", NapiValue::CreateInt64(env, static_cast<int64_t>(arg->destLen)).val_),
89 NapiValue::DeclareNapiProperty(
90 "sourceLength", NapiValue::CreateInt64(env, static_cast<int64_t>(arg->sourceLen)).val_),
91 });
92 return {obj};
93 }
94
DictionaryOutputInfo(napi_env env,std::shared_ptr<AsyncZipArg> arg)95 static NapiValue DictionaryOutputInfo(napi_env env, std::shared_ptr<AsyncZipArg> arg)
96 {
97 NapiValue obj = NapiValue::CreateObject(env);
98 obj.AddProp({
99 NapiValue::DeclareNapiProperty("status", NapiValue::CreateInt32(env, arg->errCode).val_),
100 NapiValue::DeclareNapiProperty("dictionaryLength", NapiValue::CreateInt32(env, arg->dictLength).val_),
101 });
102 return {obj};
103 }
104
DeflatePendingOutputInfo(napi_env env,std::shared_ptr<AsyncZipArg> arg)105 static NapiValue DeflatePendingOutputInfo(napi_env env, std::shared_ptr<AsyncZipArg> arg)
106 {
107 NapiValue obj = NapiValue::CreateObject(env);
108 obj.AddProp({
109 NapiValue::DeclareNapiProperty("status", NapiValue::CreateInt32(env, arg->errCode).val_),
110 NapiValue::DeclareNapiProperty("pending", NapiValue::CreateInt32(env, arg->pending).val_),
111 NapiValue::DeclareNapiProperty("bits", NapiValue::CreateInt32(env, arg->bits).val_),
112 });
113 return {obj};
114 }
115
GetZStreamInfo(napi_env env,ZipEntity * zipEntity)116 static NapiValue GetZStreamInfo(napi_env env, ZipEntity *zipEntity)
117 {
118 NapiValue obj = NapiValue::CreateObject(env);
119 obj.AddProp({
120 NapiValue::DeclareNapiProperty("availableIn", NapiValue::CreateInt32(env, zipEntity->zs.get()->avail_in).val_),
121 NapiValue::DeclareNapiProperty("totalIn", NapiValue::CreateInt64(env, zipEntity->zs.get()->total_in).val_),
122 NapiValue::DeclareNapiProperty(
123 "availableOut", NapiValue::CreateInt32(env, zipEntity->zs.get()->avail_out).val_),
124 NapiValue::DeclareNapiProperty("totalOut", NapiValue::CreateInt64(env, zipEntity->zs.get()->total_out).val_),
125 NapiValue::DeclareNapiProperty("dataType", NapiValue::CreateInt32(env, zipEntity->zs.get()->data_type).val_),
126 NapiValue::DeclareNapiProperty("adler", NapiValue::CreateInt64(env, zipEntity->zs.get()->adler).val_),
127 });
128 return { obj };
129 }
130
Constructor(napi_env env,napi_callback_info info)131 napi_value ZipNExporter::Constructor(napi_env env, napi_callback_info info)
132 {
133 NapiFuncArg funcArg(env, info);
134 if (!funcArg.InitArgs(ArgumentCount::ZERO)) {
135 NapiBusinessError().ThrowErr(env, EINVAL);
136 return nullptr;
137 }
138
139 std::unique_ptr<ZipEntity> zipEntity = std::make_unique<ZipEntity>();
140 if (!NapiClass::SetEntityFor<ZipEntity>(env, funcArg.GetThisVar(), move(zipEntity))) {
141 NapiBusinessError().ThrowErr(env, EFAULT);
142 return nullptr;
143 }
144 return funcArg.GetThisVar();
145 }
146
DeflateExport()147 std::vector<napi_property_descriptor> ZipNExporter::DeflateExport()
148 {
149 std::vector<napi_property_descriptor> props = {
150 NapiValue::DeclareNapiFunction("deflateInit", DeflateInit),
151 NapiValue::DeclareNapiFunction("deflateInit2", DeflateInit2),
152 NapiValue::DeclareNapiFunction("deflate", Deflate),
153 NapiValue::DeclareNapiFunction("deflateEnd", DeflateEnd),
154 NapiValue::DeclareNapiFunction("deflateBound", DeflateBound),
155 NapiValue::DeclareNapiFunction("deflateReset", DeflateReset),
156 NapiValue::DeclareNapiFunction("deflateResetKeep", DeflateResetKeep),
157 NapiValue::DeclareNapiFunction("deflateParams", DeflateParams),
158 NapiValue::DeclareNapiFunction("deflatePrime", DeflatePrime),
159 NapiValue::DeclareNapiFunction("deflateTune", DeflateTune),
160 NapiValue::DeclareNapiFunction("deflateSetDictionary", DeflateSetDictionary),
161 NapiValue::DeclareNapiFunction("deflateGetDictionary", DeflateGetDictionary),
162 NapiValue::DeclareNapiFunction("deflateSetHeader", DeflateSetHeader),
163 NapiValue::DeclareNapiFunction("deflatePending", DeflatePending),
164 NapiValue::DeclareNapiFunction("deflateCopy", DeflateCopy),
165 };
166 return props;
167 }
168
InflateExport()169 std::vector<napi_property_descriptor> ZipNExporter::InflateExport()
170 {
171 std::vector<napi_property_descriptor> props = {
172 NapiValue::DeclareNapiFunction("inflateInit", InflateInit),
173 NapiValue::DeclareNapiFunction("inflateInit2", InflateInit2),
174 NapiValue::DeclareNapiFunction("inflateSync", InflateSync),
175 NapiValue::DeclareNapiFunction("inflate", Inflate),
176 NapiValue::DeclareNapiFunction("inflateEnd", InflateEnd),
177 NapiValue::DeclareNapiFunction("inflateSetDictionary", InflateSetDictionary),
178 NapiValue::DeclareNapiFunction("inflateGetDictionary", InflateGetDictionary),
179 NapiValue::DeclareNapiFunction("inflateGetHeader", InflateGetHeader),
180 NapiValue::DeclareNapiFunction("inflateReset", InflateReset),
181 NapiValue::DeclareNapiFunction("inflateReset2", InflateReset2),
182 NapiValue::DeclareNapiFunction("inflateResetKeep", InflateResetKeep),
183 NapiValue::DeclareNapiFunction("inflateBackInit", InflateBackInit),
184 NapiValue::DeclareNapiFunction("inflateBack", InflateBack),
185 NapiValue::DeclareNapiFunction("inflateBackEnd", InflateBackEnd),
186 NapiValue::DeclareNapiFunction("inflateCodesUsed", InflateCodesUsed),
187 NapiValue::DeclareNapiFunction("inflatePrime", InflatePrime),
188 NapiValue::DeclareNapiFunction("inflateMark", InflateMark),
189 NapiValue::DeclareNapiFunction("inflateValidate", InflateValidate),
190 NapiValue::DeclareNapiFunction("inflateSyncPoint", InflateSyncPoint),
191 NapiValue::DeclareNapiFunction("inflateCopy", InflateCopy),
192 };
193 return props;
194 }
195
Export()196 bool ZipNExporter::Export()
197 {
198 std::vector<napi_property_descriptor> props = {
199 NapiValue::DeclareNapiFunction("setZStream", SetZStream),
200 NapiValue::DeclareNapiFunction("getZStream", GetZStream),
201 NapiValue::DeclareNapiFunction("getZStreamSync", GetZStreamSync),
202 NapiValue::DeclareNapiFunction("zlibVersion", ZlibVersion),
203 NapiValue::DeclareNapiFunction("zError", ZError),
204 NapiValue::DeclareNapiFunction("zlibCompileFlags", ZlibCompileFlags),
205 NapiValue::DeclareNapiFunction("compress", Compress),
206 NapiValue::DeclareNapiFunction("compress2", Compress2),
207 NapiValue::DeclareNapiFunction("compressBound", CompressBound),
208 NapiValue::DeclareNapiFunction("uncompress", UnCompress),
209 NapiValue::DeclareNapiFunction("uncompress2", UnCompress2),
210 };
211 for (const auto &prop : DeflateExport()) {
212 props.push_back(prop);
213 }
214
215 for (const auto &prop : InflateExport()) {
216 props.push_back(prop);
217 }
218
219 std::string className = GetClassName();
220 bool succ = false;
221 napi_value cls = nullptr;
222 std::tie(succ, cls) = NapiClass::DefineClass(exports_.env_, className, ZipNExporter::Constructor, move(props));
223 if (!succ) {
224 NapiBusinessError().ThrowErr(exports_.env_, "Failed to define class");
225 return false;
226 }
227 succ = NapiClass::SaveClass(exports_.env_, className, cls);
228 if (!succ) {
229 NapiBusinessError().ThrowErr(exports_.env_, "Failed to save class");
230 return false;
231 }
232
233 return exports_.AddProp(className, cls);
234 }
235
GetClassName()236 std::string ZipNExporter::GetClassName()
237 {
238 return ZipNExporter::className_;
239 }
240
ZipNExporter(napi_env env,napi_value exports)241 ZipNExporter::ZipNExporter(napi_env env, napi_value exports) : NapiExporter(env, exports)
242 {}
243
~ZipNExporter()244 ZipNExporter::~ZipNExporter()
245 {}
246
SetZStream(napi_env env,napi_callback_info info)247 napi_value ZipNExporter::SetZStream(napi_env env, napi_callback_info info)
248 {
249 NapiFuncArg funcArg(env, info);
250 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
251 NapiBusinessError().ThrowErr(env, EINVAL);
252 return nullptr;
253 }
254
255 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
256 if (!succ) {
257 return nullptr;
258 }
259
260 auto cbExec = [](napi_env env) -> NapiBusinessError { return NapiBusinessError(ERRNO_NOERR); };
261
262 auto cbCompl = [](napi_env env, NapiBusinessError err) -> NapiValue {
263 if (err) {
264 return {env, err.GetNapiErr(env)};
265 }
266 return {NapiValue::CreateUndefined(env)};
267 };
268
269 NapiValue thisVar(env, funcArg.GetThisVar());
270 if (funcArg.GetArgc() == ArgumentCount::ONE) {
271 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
272 }
273
274 return NapiValue::CreateUndefined(env).val_;
275 }
276
GetZStreamSync(napi_env env,napi_callback_info info)277 napi_value ZipNExporter::GetZStreamSync(napi_env env, napi_callback_info info)
278 {
279 NapiFuncArg funcArg(env, info);
280 if (!funcArg.InitArgs(ArgumentCount::ZERO, ArgumentCount::ONE)) {
281 NapiBusinessError().ThrowErr(env, EINVAL);
282 return nullptr;
283 }
284
285 /* To get entity */
286 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
287 if (!zipEntity || !zipEntity->zs) {
288 NapiBusinessError().ThrowErr(env, EFAULT);
289 return nullptr;
290 }
291
292 NapiValue obj = NapiValue::CreateObject(env);
293 obj.AddProp({
294 NapiValue::DeclareNapiProperty(
295 "availableIn", NapiValue::CreateInt32(env, zipEntity->zs.get()->avail_in).val_),
296 NapiValue::DeclareNapiProperty("totalIn", NapiValue::CreateInt64(env, zipEntity->zs.get()->total_in).val_),
297 NapiValue::DeclareNapiProperty(
298 "availableOut", NapiValue::CreateInt32(env, zipEntity->zs.get()->avail_out).val_),
299 NapiValue::DeclareNapiProperty("totalOut", NapiValue::CreateInt64(env, zipEntity->zs.get()->total_out).val_),
300 NapiValue::DeclareNapiProperty("dataType", NapiValue::CreateInt32(env, zipEntity->zs.get()->data_type).val_),
301 NapiValue::DeclareNapiProperty("adler", NapiValue::CreateInt64(env, zipEntity->zs.get()->adler).val_),
302 });
303
304 return obj.val_;
305 }
306
GetZStream(napi_env env,napi_callback_info info)307 napi_value ZipNExporter::GetZStream(napi_env env, napi_callback_info info)
308 {
309 NapiFuncArg funcArg(env, info);
310 if (!funcArg.InitArgs(ArgumentCount::ZERO, ArgumentCount::ONE)) {
311 NapiBusinessError().ThrowErr(env, EINVAL);
312 return nullptr;
313 }
314
315 /* To get entity */
316 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
317 if (!zipEntity) {
318 NapiBusinessError().ThrowErr(env, EFAULT);
319 return nullptr;
320 }
321
322 auto cbExec = [](napi_env env) -> NapiBusinessError { return NapiBusinessError(ERRNO_NOERR); };
323
324 auto cbCompl = [zipEntity](napi_env env, NapiBusinessError err) -> NapiValue {
325 if (err) {
326 return {env, err.GetNapiErr(env)};
327 } else if (!zipEntity || !zipEntity->zs) {
328 return {NapiValue::CreateUndefined(env)};
329 }
330
331 NapiValue obj = GetZStreamInfo(env, zipEntity);
332 return {obj};
333 };
334
335 NapiValue thisVar(env, funcArg.GetThisVar());
336 if (funcArg.GetArgc() == ArgumentCount::ZERO) {
337 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
338 }
339
340 return NapiValue::CreateUndefined(env).val_;
341 }
342
ZlibVersion(napi_env env,napi_callback_info info)343 napi_value ZipNExporter::ZlibVersion(napi_env env, napi_callback_info info)
344 {
345 NapiFuncArg funcArg(env, info);
346 if (!funcArg.InitArgs(ArgumentCount::ZERO, ArgumentCount::ONE)) {
347 NapiBusinessError().ThrowErr(env, EINVAL);
348 return nullptr;
349 }
350
351 /* To get entity */
352 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
353 if (!zipEntity) {
354 NapiBusinessError().ThrowErr(env, EFAULT);
355 return nullptr;
356 }
357
358 auto arg = std::make_shared<AsyncZipArg>();
359 auto cbExec = [arg](napi_env env) -> NapiBusinessError {
360 if (!arg) {
361 return NapiBusinessError(EFAULT, true);
362 }
363 arg->zliVersion = zlibVersion();
364 return NapiBusinessError(ERRNO_NOERR);
365 };
366
367 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
368 if (err) {
369 return {env, err.GetNapiErr(env)};
370 }
371 if (!arg) {
372 return {NapiValue::CreateUndefined(env)};
373 }
374 return {NapiValue::CreateUTF8String(env, std::string(reinterpret_cast<const char *>(arg->zliVersion)))};
375 };
376
377 NapiValue thisVar(env, funcArg.GetThisVar());
378 if (funcArg.GetArgc() == ArgumentCount::ZERO) {
379 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
380 }
381
382 return NapiValue::CreateUndefined(env).val_;
383 }
384
ZError(napi_env env,napi_callback_info info)385 napi_value ZipNExporter::ZError(napi_env env, napi_callback_info info)
386 {
387 NapiFuncArg funcArg(env, info);
388 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
389 NapiBusinessError().ThrowErr(env, EINVAL);
390 return nullptr;
391 }
392
393 /* To get entity */
394 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
395 if (!zipEntity) {
396 NapiBusinessError().ThrowErr(env, EFAULT);
397 return nullptr;
398 }
399
400 bool succ = false;
401 int32_t zlibError = 0;
402 std::tie(succ, zlibError) = CommonFunc::GetZErrorArg(env, funcArg);
403 if (!succ) {
404 return nullptr;
405 }
406
407 auto arg = std::make_shared<AsyncZipArg>();
408 auto cbExec = [arg, zlibError](napi_env env) -> NapiBusinessError {
409 if (!arg) {
410 return NapiBusinessError(EFAULT, true);
411 }
412 arg->zErrorMsg = zError(zlibError);
413 return NapiBusinessError(ERRNO_NOERR);
414 };
415
416 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
417 if (err) {
418 return {env, err.GetNapiErr(env)};
419 }
420 if (!arg) {
421 return {NapiValue::CreateUndefined(env)};
422 }
423 return {NapiValue::CreateUTF8String(env, std::string(reinterpret_cast<const char *>(arg->zErrorMsg)))};
424 };
425
426 NapiValue thisVar(env, funcArg.GetThisVar());
427 if (funcArg.GetArgc() == ArgumentCount::ONE) {
428 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
429 }
430
431 return NapiValue::CreateUndefined(env).val_;
432 }
433
ZlibCompileFlags(napi_env env,napi_callback_info info)434 napi_value ZipNExporter::ZlibCompileFlags(napi_env env, napi_callback_info info)
435 {
436 NapiFuncArg funcArg(env, info);
437 if (!funcArg.InitArgs(ArgumentCount::ZERO, ArgumentCount::ONE)) {
438 NapiBusinessError().ThrowErr(env, EINVAL);
439 return nullptr;
440 }
441
442 /* To get entity */
443 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
444 if (!zipEntity) {
445 NapiBusinessError().ThrowErr(env, EFAULT);
446 return nullptr;
447 }
448
449 auto arg = std::make_shared<AsyncZipArg>();
450 auto cbExec = [arg](napi_env env) -> NapiBusinessError {
451 if (!arg) {
452 return NapiBusinessError(EFAULT, true);
453 }
454 arg->zlibCompileFlags = zlibCompileFlags();
455 return NapiBusinessError(ERRNO_NOERR);
456 };
457
458 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
459 if (err) {
460 return {env, err.GetNapiErr(env)};
461 }
462 if (!arg) {
463 return {NapiValue::CreateUndefined(env)};
464 }
465 return {NapiValue::NapiValue::CreateInt32(env, arg->zlibCompileFlags)};
466 };
467
468 NapiValue thisVar(env, funcArg.GetThisVar());
469 if (funcArg.GetArgc() == ArgumentCount::ZERO) {
470 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
471 }
472
473 return NapiValue::CreateUndefined(env).val_;
474 }
475
DeflateInit(napi_env env,napi_callback_info info)476 napi_value ZipNExporter::DeflateInit(napi_env env, napi_callback_info info)
477 {
478 NapiFuncArg funcArg(env, info);
479 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
480 NapiBusinessError().ThrowErr(env, EINVAL);
481 return nullptr;
482 }
483
484 /* To get entity */
485 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
486 if (!zipEntity) {
487 NapiBusinessError().ThrowErr(env, EFAULT);
488 return nullptr;
489 }
490
491 bool succ = false;
492 z_stream zStream = {};
493 int32_t level = 0;
494 std::tie(succ, zStream, level) = CommonFunc::GetDeflateInitArg(env, funcArg);
495 if (!succ) {
496 return nullptr;
497 }
498
499 auto arg = std::make_shared<AsyncZipArg>();
500 auto cbExec = [arg, zipEntity, zStream, level](napi_env env) -> NapiBusinessError {
501 if (!arg || !zipEntity) {
502 return NapiBusinessError(EFAULT, true);
503 }
504 std::unique_ptr<z_stream> zs = std::make_unique<z_stream>(zStream);
505 arg->errCode = deflateInit(zs.get(), level);
506 if (arg->errCode < 0) {
507 return NapiBusinessError(arg->errCode, true);
508 }
509 zipEntity->zs.swap(zs);
510 return NapiBusinessError(ERRNO_NOERR);
511 };
512
513 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
514 if (err) {
515 return {env, err.GetNapiErr(env)};
516 }
517 if (!arg) {
518 return {NapiValue::CreateUndefined(env)};
519 }
520 return {NapiValue::CreateInt32(env, arg->errCode)};
521 };
522
523 NapiValue thisVar(env, funcArg.GetThisVar());
524 if (funcArg.GetArgc() == ArgumentCount::TWO) {
525 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
526 }
527
528 return NapiValue::CreateUndefined(env).val_;
529 }
530
DeflateInit2(napi_env env,napi_callback_info info)531 napi_value ZipNExporter::DeflateInit2(napi_env env, napi_callback_info info)
532 {
533 NapiFuncArg funcArg(env, info);
534 if (!funcArg.InitArgs(ArgumentCount::SIX, ArgumentCount::SEVEN)) {
535 NapiBusinessError().ThrowErr(env, EINVAL);
536 return nullptr;
537 }
538
539 /* To get entity */
540 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
541 if (!zipEntity) {
542 NapiBusinessError().ThrowErr(env, EFAULT);
543 return nullptr;
544 }
545
546 auto arg = std::make_shared<AsyncZipArg>();
547 bool succ = false;
548 z_stream zStream = {};
549 std::tie(succ, zStream, arg->level, arg->method, arg->windowBits, arg->memLevel, arg->strategy) =
550 CommonFunc::GetDeflateInit2Arg(env, funcArg);
551 if (!succ) {
552 return nullptr;
553 }
554
555 auto cbExec = [arg, zipEntity, zStream](napi_env env) -> NapiBusinessError {
556 if (!arg || !zipEntity) {
557 return NapiBusinessError(EFAULT, true);
558 }
559 std::unique_ptr<z_stream> zs = std::make_unique<z_stream>(zStream);
560 arg->errCode = deflateInit2(zs.get(), arg->level, arg->method, arg->windowBits, arg->memLevel, arg->strategy);
561 if (arg->errCode < 0) {
562 return NapiBusinessError(arg->errCode, true);
563 }
564 zipEntity->zs.swap(zs);
565 return NapiBusinessError(ERRNO_NOERR);
566 };
567
568 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
569 if (err) {
570 return {env, err.GetNapiErr(env)};
571 }
572 if (!arg) {
573 return {NapiValue::CreateUndefined(env)};
574 }
575 return {NapiValue::CreateInt32(env, arg->errCode)};
576 };
577
578 NapiValue thisVar(env, funcArg.GetThisVar());
579 if (funcArg.GetArgc() == ArgumentCount::SIX) {
580 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
581 }
582
583 return NapiValue::CreateUndefined(env).val_;
584 }
585
Deflate(napi_env env,napi_callback_info info)586 napi_value ZipNExporter::Deflate(napi_env env, napi_callback_info info)
587 {
588 NapiFuncArg funcArg(env, info);
589 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
590 NapiBusinessError().ThrowErr(env, EINVAL);
591 return nullptr;
592 }
593
594 /* To get entity */
595 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
596 if (!zipEntity) {
597 NapiBusinessError().ThrowErr(env, EFAULT);
598 return nullptr;
599 }
600
601 bool succ = false;
602 int32_t flush = 0;
603 std::tie(succ, flush) = CommonFunc::GetDeflateArg(env, funcArg);
604 if (!succ) {
605 return nullptr;
606 }
607
608 auto arg = std::make_shared<AsyncZipArg>();
609 auto cbExec = [arg, zipEntity, flush](napi_env env) -> NapiBusinessError {
610 if (!arg || !zipEntity || !zipEntity->zs) {
611 return NapiBusinessError(EFAULT, true);
612 }
613 arg->errCode = deflate(zipEntity->zs.get(), flush);
614 if (arg->errCode < 0) {
615 return NapiBusinessError(arg->errCode, true);
616 }
617 return NapiBusinessError(ERRNO_NOERR);
618 };
619
620 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
621 if (err) {
622 return {env, err.GetNapiErr(env)};
623 }
624 if (!arg) {
625 return {NapiValue::CreateUndefined(env)};
626 }
627 return {NapiValue::CreateInt32(env, arg->errCode)};
628 };
629
630 NapiValue thisVar(env, funcArg.GetThisVar());
631 if (funcArg.GetArgc() == ArgumentCount::TWO) {
632 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
633 }
634
635 return NapiValue::CreateUndefined(env).val_;
636 }
637
DeflateEnd(napi_env env,napi_callback_info info)638 napi_value ZipNExporter::DeflateEnd(napi_env env, napi_callback_info info)
639 {
640 NapiFuncArg funcArg(env, info);
641 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
642 NapiBusinessError().ThrowErr(env, EINVAL);
643 return nullptr;
644 }
645
646 /* To get entity */
647 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
648 if (!zipEntity) {
649 NapiBusinessError().ThrowErr(env, EFAULT);
650 return nullptr;
651 }
652
653 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
654 if (!succ) {
655 return nullptr;
656 }
657
658 auto arg = std::make_shared<AsyncZipArg>();
659 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
660 if (!arg || !zipEntity || !zipEntity->zs) {
661 return NapiBusinessError(EFAULT, true);
662 }
663 arg->errCode = deflateEnd(zipEntity->zs.get());
664 if (arg->errCode < 0) {
665 return NapiBusinessError(arg->errCode, true);
666 }
667 return NapiBusinessError(ERRNO_NOERR);
668 };
669
670 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
671 if (err) {
672 return {env, err.GetNapiErr(env)};
673 }
674 if (!arg) {
675 return {NapiValue::CreateUndefined(env)};
676 }
677 return {NapiValue::CreateInt32(env, arg->errCode)};
678 };
679
680 NapiValue thisVar(env, funcArg.GetThisVar());
681 if (funcArg.GetArgc() == ArgumentCount::ONE) {
682 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
683 }
684
685 return NapiValue::CreateUndefined(env).val_;
686 }
687
DeflateBound(napi_env env,napi_callback_info info)688 napi_value ZipNExporter::DeflateBound(napi_env env, napi_callback_info info)
689 {
690 NapiFuncArg funcArg(env, info);
691 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
692 NapiBusinessError().ThrowErr(env, EINVAL);
693 return nullptr;
694 }
695
696 /* To get entity */
697 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
698 if (!zipEntity) {
699 NapiBusinessError().ThrowErr(env, EFAULT);
700 return nullptr;
701 }
702
703 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
704 if (!succ) {
705 return nullptr;
706 }
707
708 uint32_t sourceLen = 0;
709 std::tie(succ, sourceLen) = CommonFunc::UnwrapInt64Params(env, funcArg);
710 if (!succ) {
711 return nullptr;
712 }
713
714 auto arg = std::make_shared<AsyncZipArg>();
715 auto cbExec = [arg, zipEntity, sourceLen](napi_env env) -> NapiBusinessError {
716 if (!arg || !zipEntity || !zipEntity->zs) {
717 return NapiBusinessError(EFAULT, true);
718 }
719 arg->errCode = static_cast<int32_t>(deflateBound(zipEntity->zs.get(), sourceLen));
720 return NapiBusinessError(ERRNO_NOERR);
721 };
722
723 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
724 if (err) {
725 return {env, err.GetNapiErr(env)};
726 }
727 if (!arg) {
728 return {NapiValue::CreateUndefined(env)};
729 }
730 return {NapiValue::CreateInt32(env, arg->errCode)};
731 };
732
733 NapiValue thisVar(env, funcArg.GetThisVar());
734 if (funcArg.GetArgc() == ArgumentCount::TWO) {
735 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
736 }
737
738 return NapiValue::CreateUndefined(env).val_;
739 }
740
DeflateReset(napi_env env,napi_callback_info info)741 napi_value ZipNExporter::DeflateReset(napi_env env, napi_callback_info info)
742 {
743 NapiFuncArg funcArg(env, info);
744 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
745 NapiBusinessError().ThrowErr(env, EINVAL);
746 return nullptr;
747 }
748
749 /* To get entity */
750 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
751 if (!zipEntity) {
752 NapiBusinessError().ThrowErr(env, EFAULT);
753 return nullptr;
754 }
755
756 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
757 if (!succ) {
758 return nullptr;
759 }
760
761 auto arg = std::make_shared<AsyncZipArg>();
762 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
763 if (!arg || !zipEntity || !zipEntity->zs) {
764 return NapiBusinessError(EFAULT, true);
765 }
766 arg->errCode = deflateReset(zipEntity->zs.get());
767 if (arg->errCode < 0) {
768 return NapiBusinessError(arg->errCode, true);
769 }
770 return NapiBusinessError(ERRNO_NOERR);
771 };
772
773 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
774 if (err) {
775 return {env, err.GetNapiErr(env)};
776 }
777 if (!arg) {
778 return {NapiValue::CreateUndefined(env)};
779 }
780 return {NapiValue::CreateInt32(env, arg->errCode)};
781 };
782
783 NapiValue thisVar(env, funcArg.GetThisVar());
784 if (funcArg.GetArgc() == ArgumentCount::ONE) {
785 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
786 }
787
788 return NapiValue::CreateUndefined(env).val_;
789 }
790
DeflateResetKeep(napi_env env,napi_callback_info info)791 napi_value ZipNExporter::DeflateResetKeep(napi_env env, napi_callback_info info)
792 {
793 NapiFuncArg funcArg(env, info);
794 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
795 NapiBusinessError().ThrowErr(env, EINVAL);
796 return nullptr;
797 }
798
799 /* To get entity */
800 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
801 if (!zipEntity) {
802 NapiBusinessError().ThrowErr(env, EFAULT);
803 return nullptr;
804 }
805
806 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
807 if (!succ) {
808 return nullptr;
809 }
810
811 auto arg = std::make_shared<AsyncZipArg>();
812 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
813 if (!arg || !zipEntity || !zipEntity->zs) {
814 return NapiBusinessError(EFAULT, true);
815 }
816 arg->errCode = deflateResetKeep(zipEntity->zs.get());
817 if (arg->errCode < 0) {
818 return NapiBusinessError(arg->errCode, true);
819 }
820 return NapiBusinessError(ERRNO_NOERR);
821 };
822
823 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
824 if (err) {
825 return {env, err.GetNapiErr(env)};
826 }
827 if (!arg) {
828 return {NapiValue::CreateUndefined(env)};
829 }
830 return {NapiValue::CreateInt32(env, arg->errCode)};
831 };
832
833 NapiValue thisVar(env, funcArg.GetThisVar());
834 if (funcArg.GetArgc() == ArgumentCount::ONE) {
835 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
836 }
837
838 return NapiValue::CreateUndefined(env).val_;
839 }
840
DeflateParams(napi_env env,napi_callback_info info)841 napi_value ZipNExporter::DeflateParams(napi_env env, napi_callback_info info)
842 {
843 NapiFuncArg funcArg(env, info);
844 if (!funcArg.InitArgs(ArgumentCount::THREE, ArgumentCount::FOUR)) {
845 NapiBusinessError().ThrowErr(env, EINVAL);
846 return nullptr;
847 }
848
849 /* To get entity */
850 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
851 if (!zipEntity) {
852 NapiBusinessError().ThrowErr(env, EFAULT);
853 return nullptr;
854 }
855
856 bool succ = false;
857 int32_t level = 0;
858 int32_t strategy = 0;
859 std::tie(succ, level, strategy) = CommonFunc::UnwrapTwoIntParams(env, funcArg);
860 if (!succ) {
861 return nullptr;
862 }
863
864 auto arg = std::make_shared<AsyncZipArg>();
865 auto cbExec = [arg, zipEntity, level, strategy](napi_env env) -> NapiBusinessError {
866 if (!arg || !zipEntity || !zipEntity->zs) {
867 return NapiBusinessError(EFAULT, true);
868 }
869 arg->errCode = deflateParams(zipEntity->zs.get(), level, strategy);
870 if (arg->errCode < 0) {
871 return NapiBusinessError(arg->errCode, true);
872 }
873 return NapiBusinessError(ERRNO_NOERR);
874 };
875
876 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
877 if (err) {
878 return {env, err.GetNapiErr(env)};
879 }
880 if (!arg) {
881 return {NapiValue::CreateUndefined(env)};
882 }
883 return {NapiValue::CreateInt32(env, arg->errCode)};
884 };
885
886 NapiValue thisVar(env, funcArg.GetThisVar());
887 if (funcArg.GetArgc() == ArgumentCount::THREE) {
888 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
889 }
890
891 return NapiValue::CreateUndefined(env).val_;
892 }
893
DeflatePrime(napi_env env,napi_callback_info info)894 napi_value ZipNExporter::DeflatePrime(napi_env env, napi_callback_info info)
895 {
896 NapiFuncArg funcArg(env, info);
897 if (!funcArg.InitArgs(ArgumentCount::THREE, ArgumentCount::FOUR)) {
898 NapiBusinessError().ThrowErr(env, EINVAL);
899 return nullptr;
900 }
901
902 /* To get entity */
903 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
904 if (!zipEntity) {
905 NapiBusinessError().ThrowErr(env, EFAULT);
906 return nullptr;
907 }
908
909 bool succ = false;
910 int32_t bits = 0;
911 int32_t value = 0;
912 std::tie(succ, bits, value) = CommonFunc::UnwrapTwoIntParams(env, funcArg);
913 if (!succ) {
914 return nullptr;
915 } else if (bits < MIN_BITS || bits > MAX_BITS) {
916 NapiBusinessError().ThrowErr(env, EINVAL);
917 return nullptr;
918 }
919
920 auto arg = std::make_shared<AsyncZipArg>();
921 auto cbExec = [arg, zipEntity, bits, value](napi_env env) -> NapiBusinessError {
922 if (!arg || !zipEntity || !zipEntity->zs) {
923 return NapiBusinessError(EFAULT, true);
924 }
925 arg->errCode = deflatePrime(zipEntity->zs.get(), bits, value);
926 if (arg->errCode < 0) {
927 return NapiBusinessError(arg->errCode, true);
928 }
929 return NapiBusinessError(ERRNO_NOERR);
930 };
931
932 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
933 if (err) {
934 return {env, err.GetNapiErr(env)};
935 }
936 if (!arg) {
937 return {NapiValue::CreateUndefined(env)};
938 }
939 return {NapiValue::CreateInt32(env, arg->errCode)};
940 };
941
942 NapiValue thisVar(env, funcArg.GetThisVar());
943 if (funcArg.GetArgc() == ArgumentCount::THREE) {
944 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
945 }
946
947 return NapiValue::CreateUndefined(env).val_;
948 }
949
DeflateTune(napi_env env,napi_callback_info info)950 napi_value ZipNExporter::DeflateTune(napi_env env, napi_callback_info info)
951 {
952 NapiFuncArg funcArg(env, info);
953 if (!funcArg.InitArgs(ArgumentCount::FIVE, ArgumentCount::SIX)) {
954 NapiBusinessError().ThrowErr(env, EINVAL);
955 return nullptr;
956 }
957
958 /* To get entity */
959 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
960 if (!zipEntity) {
961 NapiBusinessError().ThrowErr(env, EFAULT);
962 return nullptr;
963 }
964
965 bool succ = false;
966 int32_t goodLength = 0;
967 int32_t maxLazy = 0;
968 int32_t niceLength = 0;
969 int32_t maxChain = 0;
970 std::tie(succ, goodLength, maxLazy, niceLength, maxChain) = CommonFunc::UnwrapDeflateTuneParams(env, funcArg);
971 if (!succ) {
972 return nullptr;
973 }
974
975 auto arg = std::make_shared<AsyncZipArg>();
976 auto cbExec = [arg, zipEntity, goodLength, maxLazy, niceLength, maxChain](napi_env env) -> NapiBusinessError {
977 if (!arg || !zipEntity || !zipEntity->zs) {
978 return NapiBusinessError(EFAULT, true);
979 }
980 arg->errCode = deflateTune(zipEntity->zs.get(), goodLength, maxLazy, niceLength, maxChain);
981 if (arg->errCode < 0) {
982 return NapiBusinessError(arg->errCode, true);
983 }
984 return NapiBusinessError(ERRNO_NOERR);
985 };
986
987 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
988 if (err) {
989 return {env, err.GetNapiErr(env)};
990 }
991 if (!arg) {
992 return {NapiValue::CreateUndefined(env)};
993 }
994 return {NapiValue::CreateInt32(env, arg->errCode)};
995 };
996
997 NapiValue thisVar(env, funcArg.GetThisVar());
998 if (funcArg.GetArgc() == ArgumentCount::FIVE) {
999 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1000 }
1001
1002 return NapiValue::CreateUndefined(env).val_;
1003 }
1004
DeflateSetDictionary(napi_env env,napi_callback_info info)1005 napi_value ZipNExporter::DeflateSetDictionary(napi_env env, napi_callback_info info)
1006 {
1007 NapiFuncArg funcArg(env, info);
1008 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1009 NapiBusinessError().ThrowErr(env, EINVAL);
1010 return nullptr;
1011 }
1012
1013 /* To get entity */
1014 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1015 if (!zipEntity) {
1016 NapiBusinessError().ThrowErr(env, EFAULT);
1017 return nullptr;
1018 }
1019
1020 bool succ = false;
1021 void *dictionary = nullptr;
1022 size_t dictionaryLen = 0;
1023 std::tie(succ, dictionary, dictionaryLen) = CommonFunc::UnwrapArrayBufferParams(env, funcArg);
1024 if (!succ) {
1025 return nullptr;
1026 }
1027
1028 auto arg = std::make_shared<AsyncZipArg>();
1029 auto cbExec = [arg, zipEntity, dictionary, dictionaryLen](napi_env env) -> NapiBusinessError {
1030 if (!arg || !zipEntity || !zipEntity->zs) {
1031 return NapiBusinessError(EFAULT, true);
1032 }
1033 arg->errCode = deflateSetDictionary(
1034 zipEntity->zs.get(), reinterpret_cast<const Bytef *>(dictionary), static_cast<uInt>(dictionaryLen));
1035 if (arg->errCode < 0) {
1036 return NapiBusinessError(arg->errCode, true);
1037 }
1038 return NapiBusinessError(ERRNO_NOERR);
1039 };
1040
1041 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1042 if (err) {
1043 return {env, err.GetNapiErr(env)};
1044 }
1045 if (!arg) {
1046 return {NapiValue::CreateUndefined(env)};
1047 }
1048 return {NapiValue::CreateInt32(env, arg->errCode)};
1049 };
1050
1051 NapiValue thisVar(env, funcArg.GetThisVar());
1052 if (funcArg.GetArgc() == ArgumentCount::TWO) {
1053 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1054 }
1055
1056 return NapiValue::CreateUndefined(env).val_;
1057 }
1058
DeflateGetDictionary(napi_env env,napi_callback_info info)1059 napi_value ZipNExporter::DeflateGetDictionary(napi_env env, napi_callback_info info)
1060 {
1061 NapiFuncArg funcArg(env, info);
1062 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1063 NapiBusinessError().ThrowErr(env, EINVAL);
1064 return nullptr;
1065 }
1066
1067 /* To get entity */
1068 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1069 if (!zipEntity) {
1070 NapiBusinessError().ThrowErr(env, EFAULT);
1071 return nullptr;
1072 }
1073
1074 bool succ = false;
1075 void *dictionary = nullptr;
1076 auto arg = std::make_shared<AsyncZipArg>();
1077 std::tie(succ, dictionary, arg->dictLength) = CommonFunc::UnwrapArrayBufferParams(env, funcArg);
1078
1079 auto cbExec = [arg, zipEntity, dictionary](napi_env env) -> NapiBusinessError {
1080 if (!arg || !zipEntity || !zipEntity->zs) {
1081 return NapiBusinessError(EFAULT, true);
1082 }
1083 arg->errCode = deflateGetDictionary(zipEntity->zs.get(), static_cast<Bytef *>(dictionary), &arg->dictLength);
1084 if (arg->errCode < 0) {
1085 return NapiBusinessError(arg->errCode, true);
1086 }
1087 return NapiBusinessError(ERRNO_NOERR);
1088 };
1089
1090 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1091 if (err) {
1092 return {env, err.GetNapiErr(env)};
1093 }
1094 if (!arg) {
1095 return {NapiValue::CreateUndefined(env)};
1096 }
1097
1098 NapiValue obj = DictionaryOutputInfo(env, arg);
1099 return {obj};
1100 };
1101
1102 NapiValue thisVar(env, funcArg.GetThisVar());
1103 if (funcArg.GetArgc() == ArgumentCount::TWO) {
1104 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1105 }
1106
1107 return NapiValue::CreateUndefined(env).val_;
1108 }
1109
DeflateSetHeader(napi_env env,napi_callback_info info)1110 napi_value ZipNExporter::DeflateSetHeader(napi_env env, napi_callback_info info)
1111 {
1112 NapiFuncArg funcArg(env, info);
1113 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1114 NapiBusinessError().ThrowErr(env, EINVAL);
1115 return nullptr;
1116 }
1117
1118 /* To get entity */
1119 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1120 if (!zipEntity) {
1121 NapiBusinessError().ThrowErr(env, EFAULT);
1122 return nullptr;
1123 }
1124
1125 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
1126 if (!succ) {
1127 return nullptr;
1128 }
1129
1130 gz_header gzHeader = {};
1131 std::tie(succ, gzHeader) = CommonFunc::GetGZHeaderArg(env, funcArg[ArgumentPosition::SECOND]);
1132 if (!succ) {
1133 return nullptr;
1134 }
1135
1136 auto arg = std::make_shared<AsyncZipArg>();
1137 auto cbExec = [arg, zipEntity, gzHeader](napi_env env) -> NapiBusinessError {
1138 if (!arg || !zipEntity || !zipEntity->zs) {
1139 return NapiBusinessError(EFAULT, true);
1140 }
1141 arg->errCode = deflateSetHeader(zipEntity->zs.get(), const_cast<gz_headerp>(&gzHeader));
1142 if (arg->errCode < 0) {
1143 return NapiBusinessError(arg->errCode, true);
1144 }
1145 return NapiBusinessError(ERRNO_NOERR);
1146 };
1147
1148 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1149 if (err) {
1150 return {env, err.GetNapiErr(env)};
1151 }
1152 if (!arg) {
1153 return {NapiValue::CreateUndefined(env)};
1154 }
1155 return {NapiValue::CreateInt32(env, arg->errCode)};
1156 };
1157
1158 NapiValue thisVar(env, funcArg.GetThisVar());
1159 if (funcArg.GetArgc() == ArgumentCount::TWO) {
1160 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1161 }
1162
1163 return NapiValue::CreateUndefined(env).val_;
1164 }
1165
DeflatePending(napi_env env,napi_callback_info info)1166 napi_value ZipNExporter::DeflatePending(napi_env env, napi_callback_info info)
1167 {
1168 NapiFuncArg funcArg(env, info);
1169 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
1170 NapiBusinessError().ThrowErr(env, EINVAL);
1171 return nullptr;
1172 }
1173
1174 /* To get entity */
1175 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1176 if (!zipEntity) {
1177 NapiBusinessError().ThrowErr(env, EFAULT);
1178 return nullptr;
1179 }
1180
1181 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
1182 if (!succ) {
1183 return nullptr;
1184 }
1185
1186 auto arg = std::make_shared<AsyncZipArg>();
1187 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
1188 if (!arg || !zipEntity || !zipEntity->zs) {
1189 return NapiBusinessError(EFAULT, true);
1190 }
1191 arg->errCode = deflatePending(zipEntity->zs.get(), &arg->pending, &arg->bits);
1192 if (arg->errCode < 0) {
1193 return NapiBusinessError(arg->errCode, true);
1194 }
1195 return NapiBusinessError(ERRNO_NOERR);
1196 };
1197
1198 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1199 if (err) {
1200 return {env, err.GetNapiErr(env)};
1201 }
1202 if (!arg) {
1203 return {NapiValue::CreateUndefined(env)};
1204 }
1205 NapiValue obj = DeflatePendingOutputInfo(env, arg);
1206 return {obj};
1207 };
1208
1209 NapiValue thisVar(env, funcArg.GetThisVar());
1210 if (funcArg.GetArgc() == ArgumentCount::ONE) {
1211 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1212 }
1213
1214 return NapiValue::CreateUndefined(env).val_;
1215 }
1216
DeflateCopy(napi_env env,napi_callback_info info)1217 napi_value ZipNExporter::DeflateCopy(napi_env env, napi_callback_info info)
1218 {
1219 NapiFuncArg funcArg(env, info);
1220 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
1221 NapiBusinessError().ThrowErr(env, EINVAL);
1222 return nullptr;
1223 }
1224
1225 /* To get entity */
1226 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1227 if (!zipEntity) {
1228 NapiBusinessError().ThrowErr(env, EFAULT);
1229 return nullptr;
1230 }
1231
1232 auto srcZipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg[ArgumentPosition::FIRST]);
1233 if (!srcZipEntity) {
1234 NapiBusinessError().ThrowErr(env, EINVAL);
1235 return nullptr;
1236 }
1237
1238 auto arg = std::make_shared<AsyncZipArg>();
1239 auto cbExec = [arg, zipEntity, srcZipEntity](napi_env env) -> NapiBusinessError {
1240 if (!arg || !zipEntity || !srcZipEntity) {
1241 return NapiBusinessError(EFAULT, true);
1242 }
1243
1244 if (!zipEntity->zs) {
1245 std::unique_ptr<z_stream> zs = std::make_unique<z_stream>();
1246 zipEntity->zs.swap(zs);
1247 }
1248 arg->errCode = deflateCopy(zipEntity->zs.get(), srcZipEntity->zs.get());
1249 if (arg->errCode < 0) {
1250 return NapiBusinessError(arg->errCode, true);
1251 }
1252 return NapiBusinessError(ERRNO_NOERR);
1253 };
1254
1255 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1256 if (err) {
1257 return {env, err.GetNapiErr(env)};
1258 }
1259 if (!arg) {
1260 return {NapiValue::CreateUndefined(env)};
1261 }
1262 return {NapiValue::CreateInt32(env, arg->errCode)};
1263 };
1264
1265 NapiValue thisVar(env, funcArg.GetThisVar());
1266 if (funcArg.GetArgc() == ArgumentCount::ONE) {
1267 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1268 }
1269
1270 return NapiValue::CreateUndefined(env).val_;
1271 }
1272
Compress(napi_env env,napi_callback_info info)1273 napi_value ZipNExporter::Compress(napi_env env, napi_callback_info info)
1274 {
1275 NapiFuncArg funcArg(env, info);
1276 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1277 NapiBusinessError().ThrowErr(env, EINVAL);
1278 return nullptr;
1279 }
1280
1281 /* To get entity */
1282 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1283 if (!zipEntity) {
1284 NapiBusinessError().ThrowErr(env, EFAULT);
1285 return nullptr;
1286 }
1287
1288 bool succ = false;
1289 void *dest = nullptr;
1290 void *source = nullptr;
1291 auto arg = std::make_shared<AsyncZipArg>();
1292 std::tie(succ, dest, arg->destLen, source, arg->sourceLen) = CommonFunc::GetCompressArg(env, funcArg);
1293 if (!succ) {
1294 return nullptr;
1295 }
1296
1297 auto cbExec = [arg, dest, source](napi_env env) -> NapiBusinessError {
1298 if (!arg) {
1299 return NapiBusinessError(EFAULT, true);
1300 }
1301 if (!source || !dest) {
1302 return NapiBusinessError(ERROR_CODE, true);
1303 }
1304 arg->errCode =
1305 compress(reinterpret_cast<Bytef *>(dest), &arg->destLen, reinterpret_cast<Bytef *>(source), arg->sourceLen);
1306 if (arg->errCode < 0) {
1307 return NapiBusinessError(arg->errCode, true);
1308 }
1309 return NapiBusinessError(ERRNO_NOERR);
1310 };
1311
1312 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1313 if (err) {
1314 return {env, err.GetNapiErr(env)};
1315 }
1316 if (!arg) {
1317 return {NapiValue::CreateUndefined(env)};
1318 }
1319 NapiValue obj = ZipOutputInfo(env, arg);
1320 return {obj};
1321 };
1322
1323 NapiValue thisVar(env, funcArg.GetThisVar());
1324 if (funcArg.GetArgc() == ArgumentCount::TWO || funcArg.GetArgc() == ArgumentCount::THREE) {
1325 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1326 }
1327
1328 return NapiValue::CreateUndefined(env).val_;
1329 }
1330
Compress2(napi_env env,napi_callback_info info)1331 napi_value ZipNExporter::Compress2(napi_env env, napi_callback_info info)
1332 {
1333 NapiFuncArg funcArg(env, info);
1334 if (!funcArg.InitArgs(ArgumentCount::THREE, ArgumentCount::FOUR)) {
1335 NapiBusinessError().ThrowErr(env, EINVAL);
1336 return nullptr;
1337 }
1338
1339 /* To get entity */
1340 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1341 if (!zipEntity) {
1342 NapiBusinessError().ThrowErr(env, EFAULT);
1343 return nullptr;
1344 }
1345
1346 bool succ = false;
1347 void *dest = nullptr;
1348 void *source = nullptr;
1349 auto arg = std::make_shared<AsyncZipArg>();
1350 std::tie(succ, dest, arg->destLen, source, arg->sourceLen, arg->level) = CommonFunc::GetCompress2Arg(env, funcArg);
1351 if (!succ) {
1352 return nullptr;
1353 }
1354
1355 auto cbExec = [arg, dest, source](napi_env env) -> NapiBusinessError {
1356 if (!arg) {
1357 return NapiBusinessError(EFAULT, true);
1358 }
1359 if (!source || !dest) {
1360 return NapiBusinessError(ERROR_CODE, true);
1361 }
1362 arg->errCode = compress2(
1363 static_cast<Bytef *>(dest), &arg->destLen, static_cast<Bytef *>(source), arg->sourceLen, arg->level);
1364 if (arg->errCode < 0) {
1365 return NapiBusinessError(arg->errCode, true);
1366 }
1367 return NapiBusinessError(ERRNO_NOERR);
1368 };
1369
1370 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1371 if (err) {
1372 return {env, err.GetNapiErr(env)};
1373 }
1374 if (!arg) {
1375 return {NapiValue::CreateUndefined(env)};
1376 }
1377 NapiValue obj = ZipOutputInfo(env, arg);
1378 return {obj};
1379 };
1380
1381 NapiValue thisVar(env, funcArg.GetThisVar());
1382 if (funcArg.GetArgc() == ArgumentCount::THREE || funcArg.GetArgc() == ArgumentCount::FOUR) {
1383 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1384 }
1385
1386 return NapiValue::CreateUndefined(env).val_;
1387 }
1388
CompressBound(napi_env env,napi_callback_info info)1389 napi_value ZipNExporter::CompressBound(napi_env env, napi_callback_info info)
1390 {
1391 NapiFuncArg funcArg(env, info);
1392 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
1393 NapiBusinessError().ThrowErr(env, EINVAL);
1394 return nullptr;
1395 }
1396
1397 int32_t sourceLen = 0;
1398 bool succ = false;
1399 std::tie(succ, sourceLen) = CommonFunc::UnwrapInt32Params(env, funcArg[ArgumentPosition::FIRST]);
1400 if (!succ) {
1401 return nullptr;
1402 }
1403
1404 auto arg = std::make_shared<AsyncZipArg>();
1405 auto cbExec = [arg, sourceLen](napi_env env) -> NapiBusinessError {
1406 if (!arg) {
1407 return NapiBusinessError(EFAULT, true);
1408 }
1409 arg->errCode = static_cast<int32_t>(compressBound(sourceLen));
1410 return NapiBusinessError(ERRNO_NOERR);
1411 };
1412
1413 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1414 if (err) {
1415 return {env, err.GetNapiErr(env)};
1416 }
1417 if (!arg) {
1418 return {NapiValue::CreateUndefined(env)};
1419 }
1420 return {NapiValue::CreateInt32(env, arg->errCode)};
1421 };
1422
1423 NapiValue thisVar(env, funcArg.GetThisVar());
1424 if (funcArg.GetArgc() == ArgumentCount::ONE) {
1425 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1426 }
1427
1428 return NapiValue::CreateUndefined(env).val_;
1429 }
1430
UnCompress(napi_env env,napi_callback_info info)1431 napi_value ZipNExporter::UnCompress(napi_env env, napi_callback_info info)
1432 {
1433 NapiFuncArg funcArg(env, info);
1434 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1435 NapiBusinessError().ThrowErr(env, EINVAL);
1436 return nullptr;
1437 }
1438
1439 /* To get entity */
1440 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1441 if (!zipEntity) {
1442 NapiBusinessError().ThrowErr(env, EFAULT);
1443 return nullptr;
1444 }
1445
1446 bool succ = false;
1447 void *dest = nullptr;
1448 void *source = nullptr;
1449 auto arg = std::make_shared<AsyncZipArg>();
1450 std::tie(succ, dest, arg->destLen, source, arg->sourceLen) = CommonFunc::GetUnCompressArg(env, funcArg);
1451 if (!succ) {
1452 return nullptr;
1453 }
1454
1455 auto cbExec = [arg, dest, source](napi_env env) -> NapiBusinessError {
1456 if (!arg) {
1457 return NapiBusinessError(EFAULT, true);
1458 }
1459 if (!source || !dest) {
1460 return NapiBusinessError(ERROR_CODE, true);
1461 }
1462 arg->errCode =
1463 uncompress(static_cast<Bytef *>(dest), &arg->destLen, static_cast<Bytef *>(source), arg->sourceLen);
1464 if (arg->errCode < 0) {
1465 return NapiBusinessError(arg->errCode, true);
1466 }
1467 return NapiBusinessError(ERRNO_NOERR);
1468 };
1469
1470 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1471 if (err) {
1472 return {env, err.GetNapiErr(env)};
1473 }
1474 if (!arg) {
1475 return {NapiValue::CreateUndefined(env)};
1476 }
1477 NapiValue obj = ZipOutputInfo(env, arg);
1478 return {obj};
1479 };
1480
1481 NapiValue thisVar(env, funcArg.GetThisVar());
1482 if (funcArg.GetArgc() == ArgumentCount::TWO || funcArg.GetArgc() == ArgumentCount::THREE) {
1483 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1484 }
1485
1486 return NapiValue::CreateUndefined(env).val_;
1487 }
1488
UnCompress2(napi_env env,napi_callback_info info)1489 napi_value ZipNExporter::UnCompress2(napi_env env, napi_callback_info info)
1490 {
1491 NapiFuncArg funcArg(env, info);
1492 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1493 NapiBusinessError().ThrowErr(env, EINVAL);
1494 return nullptr;
1495 }
1496
1497 /* To get entity */
1498 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1499 if (!zipEntity) {
1500 NapiBusinessError().ThrowErr(env, EFAULT);
1501 return nullptr;
1502 }
1503
1504 bool succ = false;
1505 void *dest = nullptr;
1506 void *source = nullptr;
1507 auto arg = std::make_shared<AsyncZipArg>();
1508 std::tie(succ, dest, arg->destLen, source, arg->sourceLen) = CommonFunc::GetUnCompressArg(env, funcArg);
1509 if (!succ) {
1510 return nullptr;
1511 }
1512
1513 auto cbExec = [arg, dest, source](napi_env env) -> NapiBusinessError {
1514 if (!arg) {
1515 return NapiBusinessError(EFAULT, true);
1516 }
1517 if (!source || !dest) {
1518 return NapiBusinessError(ERROR_CODE, true);
1519 }
1520 arg->errCode =
1521 uncompress2(static_cast<Bytef *>(dest), &arg->destLen, static_cast<Bytef *>(source), &arg->sourceLen);
1522 if (arg->errCode < 0) {
1523 return NapiBusinessError(arg->errCode, true);
1524 }
1525 return NapiBusinessError(ERRNO_NOERR);
1526 };
1527
1528 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1529 if (err) {
1530 return {env, err.GetNapiErr(env)};
1531 }
1532 if (!arg) {
1533 return {NapiValue::CreateUndefined(env)};
1534 }
1535 NapiValue obj = DecompressionOutputInfo(env, arg);
1536 return {obj};
1537 };
1538
1539 NapiValue thisVar(env, funcArg.GetThisVar());
1540 if (funcArg.GetArgc() == ArgumentCount::TWO || funcArg.GetArgc() == ArgumentCount::THREE) {
1541 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1542 }
1543
1544 return NapiValue::CreateUndefined(env).val_;
1545 }
1546
InflateInit(napi_env env,napi_callback_info info)1547 napi_value ZipNExporter::InflateInit(napi_env env, napi_callback_info info)
1548 {
1549 NapiFuncArg funcArg(env, info);
1550 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
1551 NapiBusinessError().ThrowErr(env, EINVAL);
1552 return nullptr;
1553 }
1554
1555 /* To get entity */
1556 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1557 if (!zipEntity) {
1558 NapiBusinessError().ThrowErr(env, EFAULT);
1559 return nullptr;
1560 }
1561
1562 bool succ = false;
1563 z_stream zStream = {};
1564 HasZStreamMember hasZStreamMember = {};
1565 std::tie(succ, zStream, hasZStreamMember) = CommonFunc::GetZstreamArg(env, funcArg[ArgumentPosition::FIRST]);
1566 if (!succ) {
1567 return nullptr;
1568 }
1569
1570 auto arg = std::make_shared<AsyncZipArg>();
1571 auto cbExec = [arg, zipEntity, zStream](napi_env env) -> NapiBusinessError {
1572 if (!arg || !zipEntity) {
1573 return NapiBusinessError(EFAULT, true);
1574 }
1575 std::unique_ptr<z_stream> zs = std::make_unique<z_stream>(zStream);
1576 arg->errCode = inflateInit(zs.get());
1577 if (arg->errCode < 0) {
1578 return NapiBusinessError(arg->errCode, true);
1579 }
1580 zipEntity->zs.swap(zs);
1581 return NapiBusinessError(ERRNO_NOERR);
1582 };
1583
1584 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1585 if (err) {
1586 return {env, err.GetNapiErr(env)};
1587 }
1588 if (!arg) {
1589 return {NapiValue::CreateUndefined(env)};
1590 }
1591 return {NapiValue::CreateInt32(env, arg->errCode)};
1592 };
1593
1594 NapiValue thisVar(env, funcArg.GetThisVar());
1595 if (funcArg.GetArgc() == ArgumentCount::ONE) {
1596 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1597 }
1598
1599 return NapiValue::CreateUndefined(env).val_;
1600 }
1601
InflateInit2(napi_env env,napi_callback_info info)1602 napi_value ZipNExporter::InflateInit2(napi_env env, napi_callback_info info)
1603 {
1604 NapiFuncArg funcArg(env, info);
1605 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1606 NapiBusinessError().ThrowErr(env, EINVAL);
1607 return nullptr;
1608 }
1609
1610 /* To get entity */
1611 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1612 if (!zipEntity) {
1613 NapiBusinessError().ThrowErr(env, EFAULT);
1614 return nullptr;
1615 }
1616
1617 bool succ = false;
1618 z_stream zStream = {};
1619 int32_t windowBits = 0;
1620 std::tie(succ, zStream, windowBits) = CommonFunc::GetInflateInitArg(env, funcArg);
1621 if (!succ) {
1622 return nullptr;
1623 }
1624
1625 auto arg = std::make_shared<AsyncZipArg>();
1626 auto cbExec = [arg, zipEntity, zStream, windowBits](napi_env env) -> NapiBusinessError {
1627 if (!arg || !zipEntity) {
1628 return NapiBusinessError(EFAULT, true);
1629 }
1630 std::unique_ptr<z_stream> zs = std::make_unique<z_stream>(zStream);
1631 arg->errCode = inflateInit2(zs.get(), windowBits);
1632 if (arg->errCode < 0) {
1633 return NapiBusinessError(arg->errCode, true);
1634 }
1635 zipEntity->zs.swap(zs);
1636 return NapiBusinessError(ERRNO_NOERR);
1637 };
1638
1639 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1640 if (err) {
1641 return {env, err.GetNapiErr(env)};
1642 }
1643 if (!arg) {
1644 return {NapiValue::CreateUndefined(env)};
1645 }
1646 return {NapiValue::CreateInt32(env, arg->errCode)};
1647 };
1648
1649 NapiValue thisVar(env, funcArg.GetThisVar());
1650 if (funcArg.GetArgc() == ArgumentCount::TWO) {
1651 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1652 }
1653
1654 return NapiValue::CreateUndefined(env).val_;
1655 }
1656
InflateSync(napi_env env,napi_callback_info info)1657 napi_value ZipNExporter::InflateSync(napi_env env, napi_callback_info info)
1658 {
1659 NapiFuncArg funcArg(env, info);
1660 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
1661 NapiBusinessError().ThrowErr(env, EINVAL);
1662 return nullptr;
1663 }
1664
1665 /* To get entity */
1666 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1667 if (!zipEntity) {
1668 NapiBusinessError().ThrowErr(env, EFAULT);
1669 return nullptr;
1670 }
1671
1672 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
1673 if (!succ) {
1674 return nullptr;
1675 }
1676
1677 auto arg = std::make_shared<AsyncZipArg>();
1678 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
1679 if (!arg || !zipEntity || !zipEntity->zs) {
1680 return NapiBusinessError(EFAULT, true);
1681 }
1682 arg->errCode = inflateSync(zipEntity->zs.get());
1683 if (arg->errCode < 0) {
1684 return NapiBusinessError(arg->errCode, true);
1685 }
1686 return NapiBusinessError(ERRNO_NOERR);
1687 };
1688
1689 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1690 if (err) {
1691 return {env, err.GetNapiErr(env)};
1692 }
1693 if (!arg) {
1694 return {NapiValue::CreateUndefined(env)};
1695 }
1696 return {NapiValue::CreateInt32(env, arg->errCode)};
1697 };
1698
1699 NapiValue thisVar(env, funcArg.GetThisVar());
1700 if (funcArg.GetArgc() == ArgumentCount::ONE) {
1701 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1702 }
1703
1704 return NapiValue::CreateUndefined(env).val_;
1705 }
1706
Inflate(napi_env env,napi_callback_info info)1707 napi_value ZipNExporter::Inflate(napi_env env, napi_callback_info info)
1708 {
1709 NapiFuncArg funcArg(env, info);
1710 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1711 NapiBusinessError().ThrowErr(env, EINVAL);
1712 return nullptr;
1713 }
1714
1715 /* To get entity */
1716 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1717 if (!zipEntity) {
1718 NapiBusinessError().ThrowErr(env, EFAULT);
1719 return nullptr;
1720 }
1721
1722 bool succ = false;
1723 int32_t flush = 0;
1724 std::tie(succ, flush) = CommonFunc::GetInflateArg(env, funcArg);
1725 if (!succ) {
1726 return nullptr;
1727 }
1728
1729 auto arg = std::make_shared<AsyncZipArg>();
1730 auto cbExec = [arg, zipEntity, flush](napi_env env) -> NapiBusinessError {
1731 if (!arg || !zipEntity || !zipEntity->zs) {
1732 return NapiBusinessError(EFAULT, true);
1733 }
1734 arg->errCode = inflate(zipEntity->zs.get(), flush);
1735 if (arg->errCode < 0) {
1736 return NapiBusinessError(arg->errCode, true);
1737 }
1738 return NapiBusinessError(ERRNO_NOERR);
1739 };
1740
1741 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1742 if (err) {
1743 return {env, err.GetNapiErr(env)};
1744 }
1745 if (!arg) {
1746 return {NapiValue::CreateUndefined(env)};
1747 }
1748 return {NapiValue::CreateInt32(env, arg->errCode)};
1749 };
1750
1751 NapiValue thisVar(env, funcArg.GetThisVar());
1752 if (funcArg.GetArgc() == ArgumentCount::TWO) {
1753 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1754 }
1755
1756 return NapiValue::CreateUndefined(env).val_;
1757 }
1758
InflateEnd(napi_env env,napi_callback_info info)1759 napi_value ZipNExporter::InflateEnd(napi_env env, napi_callback_info info)
1760 {
1761 NapiFuncArg funcArg(env, info);
1762 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
1763 NapiBusinessError().ThrowErr(env, EINVAL);
1764 return nullptr;
1765 }
1766
1767 /* To get entity */
1768 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1769 if (!zipEntity) {
1770 NapiBusinessError().ThrowErr(env, EFAULT);
1771 return nullptr;
1772 }
1773
1774 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
1775 if (!succ) {
1776 return nullptr;
1777 }
1778
1779 auto arg = std::make_shared<AsyncZipArg>();
1780 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
1781 if (!arg || !zipEntity || !zipEntity->zs) {
1782 return NapiBusinessError(EFAULT, true);
1783 }
1784 arg->errCode = inflateEnd(zipEntity->zs.get());
1785 if (arg->errCode < 0) {
1786 return NapiBusinessError(arg->errCode, true);
1787 }
1788 return NapiBusinessError(ERRNO_NOERR);
1789 };
1790
1791 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1792 if (err) {
1793 return {env, err.GetNapiErr(env)};
1794 }
1795 if (!arg) {
1796 return {NapiValue::CreateUndefined(env)};
1797 }
1798 return {NapiValue::CreateInt32(env, arg->errCode)};
1799 };
1800
1801 NapiValue thisVar(env, funcArg.GetThisVar());
1802 if (funcArg.GetArgc() == ArgumentCount::ONE) {
1803 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1804 }
1805
1806 return NapiValue::CreateUndefined(env).val_;
1807 }
1808
InflateSetDictionary(napi_env env,napi_callback_info info)1809 napi_value ZipNExporter::InflateSetDictionary(napi_env env, napi_callback_info info)
1810 {
1811 NapiFuncArg funcArg(env, info);
1812 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1813 NapiBusinessError().ThrowErr(env, EINVAL);
1814 return nullptr;
1815 }
1816
1817 /* To get entity */
1818 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1819 if (!zipEntity) {
1820 NapiBusinessError().ThrowErr(env, EFAULT);
1821 return nullptr;
1822 }
1823
1824 bool succ = false;
1825 void *buf = nullptr;
1826 size_t bufLen = 0;
1827 std::tie(succ, buf, bufLen) = CommonFunc::GetInflateSetDictionaryArg(env, funcArg);
1828 if (!succ) {
1829 return nullptr;
1830 }
1831
1832 auto arg = std::make_shared<AsyncZipArg>();
1833 auto cbExec = [arg, zipEntity, buf, bufLen](napi_env env) -> NapiBusinessError {
1834 if (!arg || !zipEntity || !zipEntity->zs) {
1835 return NapiBusinessError(EFAULT, true);
1836 }
1837 arg->errCode = inflateSetDictionary(zipEntity->zs.get(), static_cast<Bytef *>(buf), static_cast<uInt>(bufLen));
1838 if (arg->errCode < 0) {
1839 return NapiBusinessError(arg->errCode, true);
1840 }
1841 return NapiBusinessError(ERRNO_NOERR);
1842 };
1843
1844 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1845 if (err) {
1846 return {env, err.GetNapiErr(env)};
1847 }
1848 if (!arg) {
1849 return {NapiValue::CreateUndefined(env)};
1850 }
1851 return {NapiValue::CreateInt32(env, arg->errCode)};
1852 };
1853
1854 NapiValue thisVar(env, funcArg.GetThisVar());
1855 if (funcArg.GetArgc() == ArgumentCount::TWO) {
1856 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1857 }
1858
1859 return NapiValue::CreateUndefined(env).val_;
1860 }
1861
InflateGetDictionary(napi_env env,napi_callback_info info)1862 napi_value ZipNExporter::InflateGetDictionary(napi_env env, napi_callback_info info)
1863 {
1864 NapiFuncArg funcArg(env, info);
1865 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1866 NapiBusinessError().ThrowErr(env, EINVAL);
1867 return nullptr;
1868 }
1869
1870 auto arg = std::make_shared<AsyncZipArg>();
1871 /* To get entity */
1872 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1873 if (!arg ||!zipEntity) {
1874 NapiBusinessError().ThrowErr(env, EFAULT);
1875 return nullptr;
1876 }
1877
1878 bool succ = false;
1879 void *buf = nullptr;
1880 std::tie(succ, buf, arg->dictLength) = CommonFunc::GetInflateSetDictionaryArg(env, funcArg);
1881 if (!succ) {
1882 return nullptr;
1883 }
1884
1885 auto cbExec = [arg, zipEntity, buf](napi_env env) -> NapiBusinessError {
1886 if (!arg || !zipEntity || !zipEntity->zs) {
1887 return NapiBusinessError(EFAULT, true);
1888 }
1889 arg->errCode = inflateGetDictionary(zipEntity->zs.get(), static_cast<Bytef *>(buf), &arg->dictLength);
1890 if (arg->errCode < 0) {
1891 return NapiBusinessError(arg->errCode, true);
1892 }
1893 return NapiBusinessError(ERRNO_NOERR);
1894 };
1895
1896 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1897 if (err) {
1898 return {env, err.GetNapiErr(env)};
1899 }
1900 if (!arg) {
1901 return {NapiValue::CreateUndefined(env)};
1902 }
1903 NapiValue obj = DictionaryOutputInfo(env, arg);
1904 return {obj};
1905 };
1906
1907 NapiValue thisVar(env, funcArg.GetThisVar());
1908 if (funcArg.GetArgc() == ArgumentCount::TWO) {
1909 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1910 }
1911
1912 return NapiValue::CreateUndefined(env).val_;
1913 }
1914
InflateResetKeep(napi_env env,napi_callback_info info)1915 napi_value ZipNExporter::InflateResetKeep(napi_env env, napi_callback_info info)
1916 {
1917 NapiFuncArg funcArg(env, info);
1918 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
1919 NapiBusinessError().ThrowErr(env, EINVAL);
1920 return nullptr;
1921 }
1922
1923 /* To get entity */
1924 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1925 if (!zipEntity) {
1926 NapiBusinessError().ThrowErr(env, EFAULT);
1927 return nullptr;
1928 }
1929
1930 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
1931 if (!succ) {
1932 return nullptr;
1933 }
1934
1935 auto arg = std::make_shared<AsyncZipArg>();
1936 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
1937 if (!arg || !zipEntity || !zipEntity->zs) {
1938 return NapiBusinessError(EFAULT, true);
1939 }
1940 arg->errCode = inflateResetKeep(zipEntity->zs.get());
1941 if (arg->errCode < 0) {
1942 return NapiBusinessError(arg->errCode, true);
1943 }
1944 return NapiBusinessError(ERRNO_NOERR);
1945 };
1946
1947 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
1948 if (err) {
1949 return {env, err.GetNapiErr(env)};
1950 }
1951 if (!arg) {
1952 return {NapiValue::CreateUndefined(env)};
1953 }
1954 return {NapiValue::CreateInt32(env, arg->errCode)};
1955 };
1956
1957 NapiValue thisVar(env, funcArg.GetThisVar());
1958 if (funcArg.GetArgc() == ArgumentCount::ONE) {
1959 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
1960 }
1961
1962 return NapiValue::CreateUndefined(env).val_;
1963 }
1964
InflateReset2(napi_env env,napi_callback_info info)1965 napi_value ZipNExporter::InflateReset2(napi_env env, napi_callback_info info)
1966 {
1967 NapiFuncArg funcArg(env, info);
1968 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
1969 NapiBusinessError().ThrowErr(env, EINVAL);
1970 return nullptr;
1971 }
1972
1973 /* To get entity */
1974 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
1975 if (!zipEntity) {
1976 NapiBusinessError().ThrowErr(env, EFAULT);
1977 return nullptr;
1978 }
1979
1980 bool succ = false;
1981 int32_t flush = 0;
1982 std::tie(succ, flush) = CommonFunc::GetInflateReset2Arg(env, funcArg);
1983 if (!succ) {
1984 return nullptr;
1985 }
1986
1987 auto arg = std::make_shared<AsyncZipArg>();
1988 auto cbExec = [arg, zipEntity, flush](napi_env env) -> NapiBusinessError {
1989 if (!arg || !zipEntity || !zipEntity->zs) {
1990 return NapiBusinessError(EFAULT, true);
1991 }
1992 arg->errCode = inflateReset2(zipEntity->zs.get(), flush);
1993 if (arg->errCode < 0) {
1994 return NapiBusinessError(arg->errCode, true);
1995 }
1996 return NapiBusinessError(ERRNO_NOERR);
1997 };
1998
1999 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2000 if (err) {
2001 return {env, err.GetNapiErr(env)};
2002 }
2003 if (!arg) {
2004 return {NapiValue::CreateUndefined(env)};
2005 }
2006 return {NapiValue::CreateInt32(env, arg->errCode)};
2007 };
2008
2009 NapiValue thisVar(env, funcArg.GetThisVar());
2010 if (funcArg.GetArgc() == ArgumentCount::TWO) {
2011 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2012 }
2013
2014 return NapiValue::CreateUndefined(env).val_;
2015 }
2016
InflateReset(napi_env env,napi_callback_info info)2017 napi_value ZipNExporter::InflateReset(napi_env env, napi_callback_info info)
2018 {
2019 NapiFuncArg funcArg(env, info);
2020 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
2021 NapiBusinessError().ThrowErr(env, EINVAL);
2022 return nullptr;
2023 }
2024
2025 /* To get entity */
2026 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2027 if (!zipEntity) {
2028 NapiBusinessError().ThrowErr(env, EFAULT);
2029 return nullptr;
2030 }
2031
2032 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
2033 if (!succ) {
2034 return nullptr;
2035 }
2036
2037 auto arg = std::make_shared<AsyncZipArg>();
2038 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
2039 if (!arg || !zipEntity || !zipEntity->zs) {
2040 return NapiBusinessError(EFAULT, true);
2041 }
2042 arg->errCode = inflateReset(zipEntity->zs.get());
2043 if (arg->errCode < 0) {
2044 return NapiBusinessError(arg->errCode, true);
2045 }
2046 return NapiBusinessError(ERRNO_NOERR);
2047 };
2048
2049 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2050 if (err) {
2051 return {env, err.GetNapiErr(env)};
2052 }
2053 if (!arg) {
2054 return {NapiValue::CreateUndefined(env)};
2055 }
2056 return {NapiValue::CreateInt32(env, arg->errCode)};
2057 };
2058
2059 NapiValue thisVar(env, funcArg.GetThisVar());
2060 if (funcArg.GetArgc() == ArgumentCount::ONE) {
2061 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2062 }
2063
2064 return NapiValue::CreateUndefined(env).val_;
2065 }
2066
InflateBackInit(napi_env env,napi_callback_info info)2067 napi_value ZipNExporter::InflateBackInit(napi_env env, napi_callback_info info)
2068 {
2069 NapiFuncArg funcArg(env, info);
2070 if (!funcArg.InitArgs(ArgumentCount::THREE, ArgumentCount::FOUR)) {
2071 NapiBusinessError().ThrowErr(env, EINVAL);
2072 return nullptr;
2073 }
2074
2075 /* To get entity */
2076 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2077 if (!zipEntity) {
2078 NapiBusinessError().ThrowErr(env, EFAULT);
2079 return nullptr;
2080 }
2081
2082 bool succ = false;
2083 int32_t windowBits = 0;
2084 void *windowBuf = nullptr;
2085 size_t bufLen = 0;
2086 std::tie(succ, windowBits, windowBuf, bufLen) = CommonFunc::GetInflateBackInitArg(env, funcArg);
2087 if (!succ) {
2088 return nullptr;
2089 }
2090
2091 auto arg = std::make_shared<AsyncZipArg>();
2092 auto cbExec = [arg, zipEntity, windowBits, windowBuf](napi_env env) -> NapiBusinessError {
2093 if (!arg || !zipEntity || !zipEntity->zs) {
2094 return NapiBusinessError(EFAULT, true);
2095 }
2096 arg->errCode = inflateBackInit(zipEntity->zs.get(), windowBits, static_cast<Bytef *>(windowBuf));
2097 if (arg->errCode < 0) {
2098 return NapiBusinessError(arg->errCode, true);
2099 }
2100 return NapiBusinessError(ERRNO_NOERR);
2101 };
2102
2103 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2104 if (err) {
2105 return {env, err.GetNapiErr(env)};
2106 }
2107 if (!arg) {
2108 return {NapiValue::CreateUndefined(env)};
2109 }
2110 return {NapiValue::CreateInt32(env, arg->errCode)};
2111 };
2112
2113 NapiValue thisVar(env, funcArg.GetThisVar());
2114 if (funcArg.GetArgc() == ArgumentCount::THREE) {
2115 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2116 }
2117
2118 return NapiValue::CreateUndefined(env).val_;
2119 }
2120
InFunc(void * inDesc,unsigned char ** buf)2121 static unsigned InFunc(void *inDesc, unsigned char **buf)
2122 {
2123 InOutDesc *in = static_cast<InOutDesc *>(inDesc);
2124 if (!in) {
2125 APP_LOGE("The in function callback is nullptr");
2126 return 0;
2127 }
2128
2129 NapiReference cb(NapiValue(in->env, in->func));
2130 if (!cb || !cb.Deref(in->env).TypeIs(napi_function)) {
2131 NapiBusinessError().ThrowErr(in->env, EINVAL);
2132 return 0;
2133 }
2134 napi_value callback = cb.Deref(in->env).val_;
2135 napi_value argv[ArgumentCount::ONE] = {in->desc};
2136 napi_value globalObj = nullptr;
2137 napi_status status = napi_get_global(in->env, &globalObj);
2138 if (status != napi_ok) {
2139 NapiBusinessError().ThrowErr(in->env, EINVAL);
2140 return 0;
2141 }
2142 napi_value return_val = nullptr;
2143 status = napi_call_function(in->env, globalObj, callback, ArgumentCount::ONE, argv, &return_val);
2144 if (status != napi_ok) {
2145 NapiBusinessError().ThrowErr(in->env, EINVAL);
2146 return 0;
2147 }
2148
2149 NapiValue bufNVal(in->env, return_val);
2150 void *buffer = nullptr;
2151 size_t bufLen = 0;
2152 bool succ = false;
2153 std::tie(succ, buffer, bufLen) = bufNVal.ToArrayBuffer();
2154 if (!succ) {
2155 NapiBusinessError().ThrowErr(in->env, EINVAL);
2156 return 0;
2157 }
2158 *buf = static_cast<unsigned char *>(buffer);
2159
2160 return bufLen;
2161 }
2162
OutFunc(void * outDesc,unsigned char * buf,unsigned len)2163 static int32_t OutFunc(void *outDesc, unsigned char *buf, unsigned len)
2164 {
2165 InOutDesc *out = static_cast<InOutDesc *>(outDesc);
2166 if (!out) {
2167 APP_LOGE("The out function callback is nullptr");
2168 return -1;
2169 }
2170
2171 NapiReference cb(NapiValue(out->env, out->func));
2172 if (!cb || !cb.Deref(out->env).TypeIs(napi_function)) {
2173 NapiBusinessError().ThrowErr(out->env, EINVAL);
2174 return -1;
2175 }
2176 napi_value callback = cb.Deref(out->env).val_;
2177 void *data = nullptr;
2178 napi_value buffer = nullptr;
2179 napi_status status = napi_create_arraybuffer(out->env, len, &data, &buffer);
2180 if (status != napi_ok) {
2181 NapiBusinessError().ThrowErr(out->env, EINVAL);
2182 return -1;
2183 }
2184 if (memcpy_s(data, len, buf, len) != EOK) {
2185 NapiBusinessError().ThrowErr(out->env, EINVAL);
2186 return -1;
2187 }
2188 napi_value bufferLen = nullptr;
2189 status = napi_create_int32(out->env, len, &bufferLen);
2190 if (status != napi_ok) {
2191 NapiBusinessError().ThrowErr(out->env, EINVAL);
2192 return -1;
2193 }
2194 napi_value argv[ArgumentCount::THREE] = {out->desc, buffer, bufferLen};
2195 napi_value globalObj = nullptr;
2196 status = napi_get_global(out->env, &globalObj);
2197 if (status != napi_ok) {
2198 NapiBusinessError().ThrowErr(out->env, EINVAL);
2199 return -1;
2200 }
2201 napi_value return_val = nullptr;
2202 status = napi_call_function(out->env, globalObj, callback, ArgumentCount::THREE, argv, &return_val);
2203 if (status != napi_ok) {
2204 NapiBusinessError().ThrowErr(out->env, EINVAL);
2205 return -1;
2206 }
2207 int32_t result = 0;
2208 status = napi_get_value_int32(out->env, return_val, &result);
2209 if (status != napi_ok) {
2210 NapiBusinessError().ThrowErr(out->env, EINVAL);
2211 return -1;
2212 }
2213 return result;
2214 }
2215
InflateBack(napi_env env,napi_callback_info info)2216 napi_value ZipNExporter::InflateBack(napi_env env, napi_callback_info info)
2217 {
2218 NapiFuncArg funcArg(env, info);
2219 if (!funcArg.InitArgs(ArgumentCount::FIVE, ArgumentCount::SIX)) {
2220 NapiBusinessError().ThrowErr(env, EINVAL);
2221 return nullptr;
2222 }
2223
2224 auto arg = std::make_shared<AsyncZipArg>();
2225 /* To get entity */
2226 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2227 if (!arg || !zipEntity) {
2228 NapiBusinessError().ThrowErr(env, EFAULT);
2229 return nullptr;
2230 }
2231
2232 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
2233 if (!succ) {
2234 return nullptr;
2235 }
2236
2237 auto inDesc = std::make_shared<InOutDesc>(
2238 env, funcArg[ArgumentPosition::SECOND], funcArg[ArgumentPosition::THIRD]);
2239 auto outDesc = std::make_shared<InOutDesc>(
2240 env, funcArg[ArgumentPosition::FOURTH], funcArg[ArgumentPosition::FIFTH]);
2241 arg->errCode = inflateBack(zipEntity->zs.get(), InFunc, inDesc.get(), OutFunc, outDesc.get());
2242 auto cbExec = [arg](napi_env env) -> NapiBusinessError {
2243 if (!arg) {
2244 return NapiBusinessError(EFAULT, true);
2245 }
2246 if (arg->errCode < 0) {
2247 return NapiBusinessError(arg->errCode, true);
2248 }
2249 return NapiBusinessError(ERRNO_NOERR);
2250 };
2251
2252 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2253 if (err) {
2254 return {env, err.GetNapiErr(env)};
2255 }
2256 if (!arg) {
2257 return {NapiValue::CreateUndefined(env)};
2258 }
2259 return {NapiValue::CreateInt32(env, arg->errCode)};
2260 };
2261
2262 NapiValue thisVar(env, funcArg.GetThisVar());
2263 if (funcArg.GetArgc() == ArgumentCount::FIVE) {
2264 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2265 }
2266
2267 return NapiValue::CreateUndefined(env).val_;
2268 }
2269
InflateBackEnd(napi_env env,napi_callback_info info)2270 napi_value ZipNExporter::InflateBackEnd(napi_env env, napi_callback_info info)
2271 {
2272 NapiFuncArg funcArg(env, info);
2273 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
2274 NapiBusinessError().ThrowErr(env, EINVAL);
2275 return nullptr;
2276 }
2277
2278 /* To get entity */
2279 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2280 if (!zipEntity) {
2281 NapiBusinessError().ThrowErr(env, EFAULT);
2282 return nullptr;
2283 }
2284
2285 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
2286 if (!succ) {
2287 return nullptr;
2288 }
2289
2290 auto arg = std::make_shared<AsyncZipArg>();
2291 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
2292 if (!arg || !zipEntity || !zipEntity->zs) {
2293 return NapiBusinessError(EFAULT, true);
2294 }
2295 arg->errCode = inflateBackEnd(zipEntity->zs.get());
2296 if (arg->errCode < 0) {
2297 return NapiBusinessError(arg->errCode, true);
2298 }
2299 return NapiBusinessError(ERRNO_NOERR);
2300 };
2301
2302 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2303 if (err) {
2304 return {env, err.GetNapiErr(env)};
2305 }
2306 if (!arg) {
2307 return {NapiValue::CreateUndefined(env)};
2308 }
2309 return {NapiValue::CreateInt32(env, arg->errCode)};
2310 };
2311
2312 NapiValue thisVar(env, funcArg.GetThisVar());
2313 if (funcArg.GetArgc() == ArgumentCount::ONE) {
2314 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2315 }
2316
2317 return NapiValue::CreateUndefined(env).val_;
2318 }
2319
InflateCodesUsed(napi_env env,napi_callback_info info)2320 napi_value ZipNExporter::InflateCodesUsed(napi_env env, napi_callback_info info)
2321 {
2322 NapiFuncArg funcArg(env, info);
2323 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
2324 NapiBusinessError().ThrowErr(env, EINVAL);
2325 return nullptr;
2326 }
2327
2328 /* To get entity */
2329 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2330 if (!zipEntity) {
2331 NapiBusinessError().ThrowErr(env, EFAULT);
2332 return nullptr;
2333 }
2334
2335 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
2336 if (!succ) {
2337 return nullptr;
2338 }
2339
2340 auto arg = std::make_shared<AsyncZipArg>();
2341 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
2342 if (!arg || !zipEntity || !zipEntity->zs) {
2343 return NapiBusinessError(EFAULT, true);
2344 }
2345 arg->errCode = static_cast<int32_t>(inflateCodesUsed(zipEntity->zs.get()));
2346 return NapiBusinessError(ERRNO_NOERR);
2347 };
2348
2349 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2350 if (err) {
2351 return {env, err.GetNapiErr(env)};
2352 }
2353 if (!arg) {
2354 return {NapiValue::CreateUndefined(env)};
2355 }
2356 return {NapiValue::CreateUint32(env, arg->errCode)};
2357 };
2358
2359 NapiValue thisVar(env, funcArg.GetThisVar());
2360 if (funcArg.GetArgc() == ArgumentCount::ONE) {
2361 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2362 }
2363
2364 return NapiValue::CreateUndefined(env).val_;
2365 }
2366
InflatePrime(napi_env env,napi_callback_info info)2367 napi_value ZipNExporter::InflatePrime(napi_env env, napi_callback_info info)
2368 {
2369 NapiFuncArg funcArg(env, info);
2370 if (!funcArg.InitArgs(ArgumentCount::THREE, ArgumentCount::FOUR)) {
2371 NapiBusinessError().ThrowErr(env, EINVAL);
2372 return nullptr;
2373 }
2374
2375 /* To get entity */
2376 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2377 if (!zipEntity) {
2378 NapiBusinessError().ThrowErr(env, EFAULT);
2379 return nullptr;
2380 }
2381
2382 bool succ = false;
2383 int32_t bits = 0;
2384 int32_t value = 0;
2385 std::tie(succ, bits, value) = CommonFunc::GetInflatePrimeArg(env, funcArg);
2386 if (!succ) {
2387 return nullptr;
2388 }
2389
2390 auto arg = std::make_shared<AsyncZipArg>();
2391 auto cbExec = [arg, zipEntity, bits, value](napi_env env) -> NapiBusinessError {
2392 if (!arg || !zipEntity || !zipEntity->zs) {
2393 return NapiBusinessError(EFAULT, true);
2394 }
2395 arg->errCode = inflatePrime(zipEntity->zs.get(), bits, value);
2396 if (arg->errCode < 0) {
2397 return NapiBusinessError(arg->errCode, true);
2398 }
2399 return NapiBusinessError(ERRNO_NOERR);
2400 };
2401
2402 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2403 if (err) {
2404 return {env, err.GetNapiErr(env)};
2405 }
2406 if (!arg) {
2407 return {NapiValue::CreateUndefined(env)};
2408 }
2409 return {NapiValue::CreateInt32(env, arg->errCode)};
2410 };
2411
2412 NapiValue thisVar(env, funcArg.GetThisVar());
2413 if (funcArg.GetArgc() == ArgumentCount::THREE) {
2414 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2415 }
2416
2417 return NapiValue::CreateUndefined(env).val_;
2418 }
2419
InflateMark(napi_env env,napi_callback_info info)2420 napi_value ZipNExporter::InflateMark(napi_env env, napi_callback_info info)
2421 {
2422 NapiFuncArg funcArg(env, info);
2423 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
2424 NapiBusinessError().ThrowErr(env, EINVAL);
2425 return nullptr;
2426 }
2427
2428 /* To get entity */
2429 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2430 if (!zipEntity) {
2431 NapiBusinessError().ThrowErr(env, EFAULT);
2432 return nullptr;
2433 }
2434
2435 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
2436 if (!succ) {
2437 return nullptr;
2438 }
2439
2440 auto arg = std::make_shared<AsyncZipArg>();
2441 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
2442 if (!arg || !zipEntity || !zipEntity->zs) {
2443 return NapiBusinessError(EFAULT, true);
2444 }
2445 arg->errCode = inflateMark(zipEntity->zs.get());
2446 return NapiBusinessError(ERRNO_NOERR);
2447 };
2448
2449 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2450 if (err) {
2451 return {env, err.GetNapiErr(env)};
2452 }
2453 if (!arg) {
2454 return {NapiValue::CreateUndefined(env)};
2455 }
2456 return {NapiValue::CreateInt32(env, arg->errCode)};
2457 };
2458
2459 NapiValue thisVar(env, funcArg.GetThisVar());
2460 if (funcArg.GetArgc() == ArgumentCount::ONE) {
2461 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2462 }
2463
2464 return NapiValue::CreateUndefined(env).val_;
2465 }
2466
InflateValidate(napi_env env,napi_callback_info info)2467 napi_value ZipNExporter::InflateValidate(napi_env env, napi_callback_info info)
2468 {
2469 NapiFuncArg funcArg(env, info);
2470 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
2471 NapiBusinessError().ThrowErr(env, EINVAL);
2472 return nullptr;
2473 }
2474
2475 /* To get entity */
2476 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2477 if (!zipEntity) {
2478 NapiBusinessError().ThrowErr(env, EFAULT);
2479 return nullptr;
2480 }
2481
2482 bool succ = false;
2483 int32_t check = 0;
2484 std::tie(succ, check) = CommonFunc::GetInflateValidateArg(env, funcArg);
2485 if (!succ) {
2486 return nullptr;
2487 }
2488
2489 auto arg = std::make_shared<AsyncZipArg>();
2490 auto cbExec = [arg, zipEntity, check](napi_env env) -> NapiBusinessError {
2491 if (!arg || !zipEntity || !zipEntity->zs) {
2492 return NapiBusinessError(EFAULT, true);
2493 }
2494 arg->errCode = inflateValidate(zipEntity->zs.get(), check);
2495 if (arg->errCode < 0) {
2496 return NapiBusinessError(arg->errCode, true);
2497 }
2498 return NapiBusinessError(ERRNO_NOERR);
2499 };
2500
2501 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2502 if (err) {
2503 return {env, err.GetNapiErr(env)};
2504 }
2505 if (!arg) {
2506 return {NapiValue::CreateUndefined(env)};
2507 }
2508 return {NapiValue::CreateInt32(env, arg->errCode)};
2509 };
2510
2511 NapiValue thisVar(env, funcArg.GetThisVar());
2512 if (funcArg.GetArgc() == ArgumentCount::TWO) {
2513 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2514 }
2515
2516 return NapiValue::CreateUndefined(env).val_;
2517 }
2518
InflateSyncPoint(napi_env env,napi_callback_info info)2519 napi_value ZipNExporter::InflateSyncPoint(napi_env env, napi_callback_info info)
2520 {
2521 NapiFuncArg funcArg(env, info);
2522 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
2523 NapiBusinessError().ThrowErr(env, EINVAL);
2524 return nullptr;
2525 }
2526
2527 /* To get entity */
2528 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2529 if (!zipEntity) {
2530 NapiBusinessError().ThrowErr(env, EFAULT);
2531 return nullptr;
2532 }
2533
2534 bool succ = CommonFunc::SetZStreamValue(env, funcArg);
2535 if (!succ) {
2536 return nullptr;
2537 }
2538
2539 auto arg = std::make_shared<AsyncZipArg>();
2540 auto cbExec = [arg, zipEntity](napi_env env) -> NapiBusinessError {
2541 if (!arg || !zipEntity || !zipEntity->zs) {
2542 return NapiBusinessError(EFAULT, true);
2543 }
2544 arg->errCode = inflateSyncPoint(zipEntity->zs.get());
2545 if (arg->errCode < 0) {
2546 return NapiBusinessError(arg->errCode, true);
2547 }
2548 return NapiBusinessError(ERRNO_NOERR);
2549 };
2550
2551 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2552 if (err) {
2553 return {env, err.GetNapiErr(env)};
2554 }
2555 if (!arg) {
2556 return {NapiValue::CreateUndefined(env)};
2557 }
2558 return {NapiValue::CreateInt32(env, arg->errCode)};
2559 };
2560
2561 NapiValue thisVar(env, funcArg.GetThisVar());
2562 if (funcArg.GetArgc() == ArgumentCount::ONE) {
2563 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2564 }
2565
2566 return NapiValue::CreateUndefined(env).val_;
2567 }
2568
InflateCopy(napi_env env,napi_callback_info info)2569 napi_value ZipNExporter::InflateCopy(napi_env env, napi_callback_info info)
2570 {
2571 NapiFuncArg funcArg(env, info);
2572 if (!funcArg.InitArgs(ArgumentCount::ONE, ArgumentCount::TWO)) {
2573 NapiBusinessError().ThrowErr(env, EINVAL);
2574 return nullptr;
2575 }
2576
2577 /* To get entity */
2578 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2579 if (!zipEntity) {
2580 NapiBusinessError().ThrowErr(env, EFAULT);
2581 return nullptr;
2582 }
2583
2584 auto srcZipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg[ArgumentPosition::FIRST]);
2585 if (!srcZipEntity) {
2586 NapiBusinessError().ThrowErr(env, EINVAL);
2587 return nullptr;
2588 }
2589
2590 auto arg = std::make_shared<AsyncZipArg>();
2591 auto cbExec = [arg, zipEntity, srcZipEntity](napi_env env) -> NapiBusinessError {
2592 if (!arg || !zipEntity || !srcZipEntity) {
2593 return NapiBusinessError(EFAULT, true);
2594 }
2595
2596 if (!zipEntity->zs) {
2597 std::unique_ptr<z_stream> zs = std::make_unique<z_stream>();
2598 zipEntity->zs.swap(zs);
2599 }
2600 arg->errCode = inflateCopy(zipEntity->zs.get(), srcZipEntity->zs.get());
2601 if (arg->errCode < 0) {
2602 return NapiBusinessError(arg->errCode, true);
2603 }
2604 return NapiBusinessError(ERRNO_NOERR);
2605 };
2606
2607 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2608 if (err) {
2609 return {env, err.GetNapiErr(env)};
2610 }
2611 if (!arg) {
2612 return {NapiValue::CreateUndefined(env)};
2613 }
2614 return {NapiValue::CreateInt32(env, arg->errCode)};
2615 };
2616
2617 NapiValue thisVar(env, funcArg.GetThisVar());
2618 if (funcArg.GetArgc() == ArgumentCount::ONE) {
2619 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2620 }
2621
2622 return NapiValue::CreateUndefined(env).val_;
2623 }
2624
InflateGetHeader(napi_env env,napi_callback_info info)2625 napi_value ZipNExporter::InflateGetHeader(napi_env env, napi_callback_info info)
2626 {
2627 NapiFuncArg funcArg(env, info);
2628 if (!funcArg.InitArgs(ArgumentCount::TWO, ArgumentCount::THREE)) {
2629 NapiBusinessError().ThrowErr(env, EINVAL);
2630 return nullptr;
2631 }
2632
2633 /* To get entity */
2634 auto zipEntity = NapiClass::GetEntityOf<ZipEntity>(env, funcArg.GetThisVar());
2635 if (!zipEntity) {
2636 NapiBusinessError().ThrowErr(env, EFAULT);
2637 return nullptr;
2638 }
2639
2640 bool succ = false;
2641 gz_header gzHeader = {};
2642 std::tie(succ, gzHeader) = CommonFunc::GetInflateGetHeaderArg(env, funcArg);
2643 if (!succ) {
2644 return nullptr;
2645 }
2646
2647 auto arg = std::make_shared<AsyncZipArg>();
2648 auto cbExec = [arg, zipEntity, gzHeader](napi_env env) -> NapiBusinessError {
2649 if (!arg || !zipEntity || !zipEntity->zs) {
2650 return NapiBusinessError(EFAULT, true);
2651 }
2652 arg->errCode = inflateGetHeader(zipEntity->zs.get(), const_cast<gz_headerp>(&gzHeader));
2653 if (arg->errCode < 0) {
2654 return NapiBusinessError(arg->errCode, true);
2655 }
2656 return NapiBusinessError(ERRNO_NOERR);
2657 };
2658
2659 auto cbCompl = [arg](napi_env env, NapiBusinessError err) -> NapiValue {
2660 if (err) {
2661 return {env, err.GetNapiErr(env)};
2662 }
2663 if (!arg) {
2664 return {NapiValue::CreateUndefined(env)};
2665 }
2666 return {NapiValue::CreateInt32(env, arg->errCode)};
2667 };
2668
2669 NapiValue thisVar(env, funcArg.GetThisVar());
2670 if (funcArg.GetArgc() == ArgumentCount::TWO) {
2671 return NapiAsyncWorkPromise(env, thisVar).Schedule(PROCEDURE_ZIP_NAME, cbExec, cbCompl).val_;
2672 }
2673
2674 return NapiValue::CreateUndefined(env).val_;
2675 }
2676
2677 } // namespace LIBZIP
2678 } // namespace AppExecFwk
2679 } // namespace OHOS
2680