1 /*
2  * Copyright (c) 2021-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 "prop_n_exporter.h"
17 
18 #include <cstring>
19 #include <iostream>
20 #include <memory>
21 #include <sstream>
22 #include <unistd.h>
23 
24 #include "../common_func.h"
25 #include "chmod.h"
26 #include "chown.h"
27 #include "close.h"
28 #include "copy_file.h"
29 #include "create_stream.h"
30 #include "fchmod.h"
31 #include "fchown.h"
32 #include "fdatasync.h"
33 #include "fdopen_stream.h"
34 #include "fstat.h"
35 #include "fsync.h"
36 #include "ftruncate.h"
37 #include "hash.h"
38 #include "lchown.h"
39 #include "link.h"
40 #include "lseek.h"
41 #include "lstat.h"
42 #include "mkdtemp.h"
43 #include "open.h"
44 #include "open_dir.h"
45 #include "posix_fallocate.h"
46 #include "read_dir.h"
47 #include "read_text.h"
48 #include "rename.h"
49 #include "rmdir.h"
50 #include "rmdirent.h"
51 #include "stat.h"
52 #include "symlink.h"
53 #include "truncate.h"
54 #include "watcher.h"
55 
56 namespace OHOS {
57 namespace DistributedFS {
58 namespace ModuleFileIO {
59 using namespace std;
60 namespace {
61     static constexpr int MODE_RUO_RWX = 0770;
62 }
63 
AccessSync(napi_env env,napi_callback_info info)64 napi_value PropNExporter::AccessSync(napi_env env, napi_callback_info info)
65 {
66     NFuncArg funcArg(env, info);
67     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
68         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
69         return nullptr;
70     }
71 
72     auto [succ, path, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8StringPath();
73     if (!succ) {
74         UniError(EINVAL).ThrowErr(env, "Invalid path");
75         return nullptr;
76     }
77 
78     int32_t mode = 0;
79     if (funcArg.GetArgc() == NARG_CNT::TWO) {
80         tie(succ, mode) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32(mode);
81         if (!succ || mode < 0) {
82             UniError(EINVAL).ThrowErr(env, "Invalid mode");
83             return nullptr;
84         }
85     }
86     int ret = access(path.get(), mode);
87     if (ret == -1) {
88         UniError(errno).ThrowErr(env);
89         return nullptr;
90     }
91 
92     return NVal::CreateUndefined(env).val_;
93 }
94 
Access(napi_env env,napi_callback_info info)95 napi_value PropNExporter::Access(napi_env env, napi_callback_info info)
96 {
97     NFuncArg funcArg(env, info);
98     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) {
99         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
100         return nullptr;
101     }
102 
103     auto [succ, path, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8StringPath();
104     if (!succ) {
105         UniError(EINVAL).ThrowErr(env, "Invalid path");
106         return nullptr;
107     }
108 
109     int32_t mode = 0;
110     if (funcArg.GetArgc() >= NARG_CNT::TWO) {
111         tie(succ, mode) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32(mode);
112         if (!succ || mode < 0) {
113             UniError(EINVAL).ThrowErr(env, "Invalid mode");
114             return nullptr;
115         }
116     }
117 
118     auto cbExec = [path = string(path.get()), mode](napi_env env) -> UniError {
119         int ret = access(path.c_str(), mode);
120         if (ret == -1) {
121             return UniError(errno);
122         } else {
123             return UniError(ERRNO_NOERR);
124         }
125     };
126 
127     auto cbComplete = [](napi_env env, UniError err) -> NVal {
128         if (err) {
129             return { env, err.GetNapiErr(env) };
130         } else {
131             return NVal::CreateUndefined(env);
132         }
133     };
134 
135     const string procedureName = "FileIOAccess";
136     NVal thisVar(env, funcArg.GetThisVar());
137     if (funcArg.GetArgc() == NARG_CNT::ONE || (funcArg.GetArgc() == NARG_CNT::TWO &&
138         !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function))) {
139         return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
140     } else {
141         int cbInd = ((funcArg.GetArgc() == NARG_CNT::TWO) ? NARG_POS::SECOND : NARG_POS::THIRD);
142         NVal cb(env, funcArg[cbInd]);
143         return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
144     }
145 }
146 
Unlink(napi_env env,napi_callback_info info)147 napi_value PropNExporter::Unlink(napi_env env, napi_callback_info info)
148 {
149     NFuncArg funcArg(env, info);
150     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
151         UniError(EINVAL).ThrowErr(env, "Number of Arguments Unmatched");
152         return nullptr;
153     }
154 
155     auto [succ, path, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8StringPath();
156     if (!succ) {
157         UniError(EINVAL).ThrowErr(env, "Invalid path");
158         return nullptr;
159     }
160 
161     auto cbExec = [path = string(path.get())](napi_env env) -> UniError {
162         if (unlink(path.c_str()) == -1) {
163             return UniError(errno);
164         } else {
165             return UniError(ERRNO_NOERR);
166         }
167     };
168 
169     auto cbCompl = [](napi_env env, UniError err) -> NVal {
170         if (err) {
171             return { env, err.GetNapiErr(env) };
172         }
173         return { NVal::CreateUndefined(env) };
174     };
175 
176     NVal thisVar(env, funcArg.GetThisVar());
177     const string procedureName = "FileIOStreamUnlink";
178     if (funcArg.GetArgc() == NARG_CNT::ONE) {
179         return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
180     } else {
181         NVal cb(env, funcArg[NARG_POS::SECOND]);
182         return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
183     }
184 }
185 
Mkdir(napi_env env,napi_callback_info info)186 napi_value PropNExporter::Mkdir(napi_env env, napi_callback_info info)
187 {
188     NFuncArg funcArg(env, info);
189     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) {
190         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
191         return nullptr;
192     }
193 
194     auto [succ, path, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8StringPath();
195     if (!succ) {
196         UniError(EINVAL).ThrowErr(env, "Invalid path");
197         return nullptr;
198     }
199 
200     int32_t mode = MODE_RUO_RWX;
201     if (funcArg.GetArgc() >= NARG_CNT::TWO) {
202         bool succGetMode = false;
203         tie(succGetMode, mode) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32(mode);
204         if (!succGetMode || mode < 0) {
205             UniError(EINVAL).ThrowErr(env, "Invalid mode");
206             return nullptr;
207         }
208     }
209     auto cbExec = [path = string(path.get()), mode](napi_env env) -> UniError {
210         if (mkdir(path.c_str(), mode) == -1) {
211             return UniError(errno);
212         }
213         return UniError(ERRNO_NOERR);
214     };
215 
216     auto cbCompl = [](napi_env env, UniError err) -> NVal {
217         if (err) {
218             return { env, err.GetNapiErr(env) };
219         }
220         return { NVal::CreateUndefined(env) };
221     };
222 
223     NVal thisVar(env, funcArg.GetThisVar());
224     const string procedureName = "fileioMkdir";
225     if (funcArg.GetArgc() == NARG_CNT::ONE || (funcArg.GetArgc() == NARG_CNT::TWO &&
226         !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function))) {
227         return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
228     } else {
229         int cbIdx = ((funcArg.GetArgc() == NARG_CNT::TWO) ? NARG_POS::SECOND : NARG_POS::THIRD);
230         NVal cb(env, funcArg[cbIdx]);
231         return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
232     }
233 }
234 
MkdirSync(napi_env env,napi_callback_info info)235 napi_value PropNExporter::MkdirSync(napi_env env, napi_callback_info info)
236 {
237     NFuncArg funcArg(env, info);
238     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
239         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
240         return nullptr;
241     }
242 
243     auto [succ, path, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8StringPath();
244     if (!succ) {
245         UniError(EINVAL).ThrowErr(env, "Invalid path");
246         return nullptr;
247     }
248 
249     int32_t mode = MODE_RUO_RWX;
250     if (funcArg.GetArgc() >= NARG_CNT::TWO) {
251         bool succ = false;
252         tie(succ, mode) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32(mode);
253         if (!succ || mode < 0) {
254             UniError(EINVAL).ThrowErr(env, "Invalid mode");
255             return nullptr;
256         }
257     }
258     int ret = mkdir(path.get(), mode);
259     if (ret == -1) {
260         UniError(errno).ThrowErr(env);
261         return nullptr;
262     }
263 
264     return NVal::CreateUndefined(env).val_;
265 }
266 
FchmodSync(napi_env env,napi_callback_info info)267 napi_value PropNExporter::FchmodSync(napi_env env, napi_callback_info info)
268 {
269     NFuncArg funcArg(env, info);
270     if (!funcArg.InitArgs(NARG_CNT::TWO)) {
271         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
272         return nullptr;
273     }
274 
275     bool succ = false;
276     int fd = -1;
277     tie(succ, fd) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
278     if (!succ || fd < 0) {
279         UniError(EINVAL).ThrowErr(env, "Invalid fd");
280         return nullptr;
281     }
282 
283     int mode = 0;
284     tie(succ, mode) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
285     if (!succ) {
286         UniError(EINVAL).ThrowErr(env, "Invalid mode");
287         return nullptr;
288     }
289 
290     int ret = fchmod(fd, mode);
291     if (ret == -1) {
292         UniError(errno).ThrowErr(env);
293         return nullptr;
294     }
295 
296     return NVal::CreateUndefined(env).val_;
297 }
298 
FchownSync(napi_env env,napi_callback_info info)299 napi_value PropNExporter::FchownSync(napi_env env, napi_callback_info info)
300 {
301     NFuncArg funcArg(env, info);
302     if (!funcArg.InitArgs(NARG_CNT::THREE)) {
303         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
304         return nullptr;
305     }
306 
307     bool succ = false;
308 
309     int fd = -1;
310     tie(succ, fd) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
311     if (!succ || fd < 0) {
312         UniError(EINVAL).ThrowErr(env, "Invalid fd");
313         return nullptr;
314     }
315 
316     int owner;
317     tie(succ, owner) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
318     if (!succ) {
319         UniError(EINVAL).ThrowErr(env, "Invalid owner");
320         return nullptr;
321     }
322 
323     int group;
324     tie(succ, group) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
325     if (!succ) {
326         UniError(EINVAL).ThrowErr(env, "Invalid group");
327         return nullptr;
328     }
329 
330     int ret = fchown(fd, owner, group);
331     if (ret == -1) {
332         UniError(errno).ThrowErr(env);
333         return nullptr;
334     }
335 
336     return NVal::CreateUndefined(env).val_;
337 }
338 
ReadSync(napi_env env,napi_callback_info info)339 napi_value PropNExporter::ReadSync(napi_env env, napi_callback_info info)
340 {
341     NFuncArg funcArg(env, info);
342     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
343         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
344         return nullptr;
345     }
346 
347     bool succ = false;
348     int fd = -1;
349     tie(succ, fd) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
350     if (!succ || fd < 0) {
351         UniError(EINVAL).ThrowErr(env, "Invalid fd");
352         return nullptr;
353     }
354 
355     void *buf = nullptr;
356     size_t len = 0;
357     int64_t pos = -1;
358     tie(succ, buf, len, pos, ignore) =
359         CommonFunc::GetReadArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
360     if (!succ) {
361         return nullptr;
362     }
363 
364     ssize_t actLen = 0;
365     if (pos >= 0) {
366         actLen = pread(fd, buf, len, pos);
367     } else {
368         actLen = read(fd, buf, len);
369     }
370 
371     if (actLen == -1) {
372         UniError(errno).ThrowErr(env);
373         return nullptr;
374     }
375 
376     return NVal::CreateInt64(env, actLen).val_;
377 }
378 
379 struct AsyncIOReadArg {
380     ssize_t lenRead { 0 };
381     int64_t offset { 0 };
382     NRef refReadBuf;
383 
AsyncIOReadArgOHOS::DistributedFS::ModuleFileIO::AsyncIOReadArg384     explicit AsyncIOReadArg(NVal jsReadBuf) : refReadBuf(jsReadBuf) {}
385     ~AsyncIOReadArg() = default;
386 };
387 
ReadCallbackExecutor(napi_env env,ssize_t actLen,shared_ptr<AsyncIOReadArg> arg,int64_t offset)388 static UniError ReadCallbackExecutor(napi_env env, ssize_t actLen, shared_ptr<AsyncIOReadArg> arg, int64_t offset)
389 {
390     if (actLen == -1) {
391         return UniError(errno);
392     } else {
393         arg->lenRead = actLen;
394         arg->offset = offset;
395         return UniError(ERRNO_NOERR);
396     }
397 }
398 
ReadCallbackCompleter(napi_env env,UniError err,shared_ptr<AsyncIOReadArg> arg)399 static NVal ReadCallbackCompleter(napi_env env, UniError err, shared_ptr<AsyncIOReadArg> arg)
400 {
401     if (err) {
402         return { env, err.GetNapiErr(env) };
403     }
404     NVal obj = NVal::CreateObject(env);
405     obj.AddProp({
406         NVal::DeclareNapiProperty("bytesRead", NVal::CreateInt64(env, arg->lenRead).val_),
407         NVal::DeclareNapiProperty("buffer", arg->refReadBuf.Deref(env).val_),
408         NVal::DeclareNapiProperty("offset", NVal::CreateInt64(env, arg->offset).val_)
409     });
410     return { obj };
411 }
412 
Read(napi_env env,napi_callback_info info)413 napi_value PropNExporter::Read(napi_env env, napi_callback_info info)
414 {
415     NFuncArg funcArg(env, info);
416     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
417         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
418         return nullptr;
419     }
420 
421     bool succ = false;
422     void *buf = nullptr;
423     size_t len = 0;
424     int fd = -1;
425     int64_t pos = -1;
426     int64_t offset = 0;
427     tie(succ, fd) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
428     if (!succ || fd < 0) {
429         UniError(EINVAL).ThrowErr(env, "Invalid fd");
430         return nullptr;
431     }
432 
433     tie(succ, buf, len, pos, offset) =
434         CommonFunc::GetReadArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
435     if (!succ) {
436         return nullptr;
437     }
438 
439     auto arg = make_shared<AsyncIOReadArg>(NVal(env, funcArg[NARG_POS::SECOND]));
440     auto cbExec = [arg, buf, len, fd, pos, offset](napi_env env) -> UniError {
441         ssize_t actLen = 0;
442         if (pos >= 0) {
443             actLen = pread(fd, buf, len, pos);
444         } else {
445             actLen = read(fd, buf, len);
446         }
447         return ReadCallbackExecutor(env, actLen, arg, offset);
448     };
449 
450     auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
451         return ReadCallbackCompleter(env, err, arg);
452     };
453 
454     NVal thisVar(env, funcArg.GetThisVar());
455     if (funcArg.GetArgc() == NARG_CNT::TWO || (funcArg.GetArgc() == NARG_CNT::THREE &&
456         !NVal(env, funcArg[NARG_POS::THIRD]).TypeIs(napi_function))) {
457         return NAsyncWorkPromise(env, thisVar).Schedule("FileIORead", cbExec, cbCompl).val_;
458     } else {
459         int cbIdx = ((funcArg.GetArgc() == NARG_CNT::THREE) ? NARG_POS::THIRD : NARG_POS::FOURTH);
460         NVal cb(env, funcArg[cbIdx]);
461         return NAsyncWorkCallback(env, thisVar, cb).Schedule("FileIORead", cbExec, cbCompl).val_;
462     }
463 }
464 
WriteExec(shared_ptr<AsyncIOWrtieArg> arg,void * buf,size_t len,int fd,int64_t position)465 static UniError WriteExec(shared_ptr<AsyncIOWrtieArg> arg, void *buf, size_t len, int fd, int64_t position)
466 {
467     if (position >= 0) {
468         arg->actLen = pwrite(fd, buf, len, position);
469     } else {
470         arg->actLen = write(fd, buf, len);
471     }
472     if (arg->actLen == -1) {
473         return UniError(errno);
474     }
475 
476     return UniError(ERRNO_NOERR);
477 }
478 
Write(napi_env env,napi_callback_info info)479 napi_value PropNExporter::Write(napi_env env, napi_callback_info info)
480 {
481     NFuncArg funcArg(env, info);
482     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
483         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
484         return nullptr;
485     }
486 
487     bool succ = false;
488     int fd = -1;
489     tie(succ, fd) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
490     if (!succ || fd < 0) {
491         UniError(EINVAL).ThrowErr(env, "Invalid fd");
492         return nullptr;
493     }
494 
495     unique_ptr<char[]> bufGuard = nullptr;
496     void *buf = nullptr;
497     size_t len = 0;
498     int64_t position = -1;
499     tie(succ, bufGuard, buf, len, position) =
500         CommonFunc::GetWriteArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
501     if (!succ) {
502         return nullptr;
503     }
504 
505     auto arg = make_shared<AsyncIOWrtieArg>(move(bufGuard));
506     auto cbExec = [arg, buf, len, fd, position](napi_env env) -> UniError {
507         return WriteExec(arg, buf, len, fd, position);
508     };
509 
510     auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
511         if (err) {
512             return { env, err.GetNapiErr(env) };
513         }
514         return { NVal::CreateInt64(env, arg->actLen) };
515     };
516 
517     NVal thisVar(env, funcArg.GetThisVar());
518     if (funcArg.GetArgc() == NARG_CNT::TWO || (funcArg.GetArgc() == NARG_CNT::THREE &&
519         !NVal(env, funcArg[NARG_POS::THIRD]).TypeIs(napi_function))) {
520         return NAsyncWorkPromise(env, thisVar).Schedule("FileIOWrite", cbExec, cbCompl).val_;
521     } else {
522         int cbIdx = ((funcArg.GetArgc() == NARG_CNT::THREE) ? NARG_POS::THIRD : NARG_POS::FOURTH);
523         NVal cb(env, funcArg[cbIdx]);
524         return NAsyncWorkCallback(env, thisVar, cb).Schedule("FileIOWrite", cbExec, cbCompl).val_;
525     }
526 }
527 
UnlinkSync(napi_env env,napi_callback_info info)528 napi_value PropNExporter::UnlinkSync(napi_env env, napi_callback_info info)
529 {
530     NFuncArg funcArg(env, info);
531     if (!funcArg.InitArgs(NARG_CNT::ONE)) {
532         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
533         return nullptr;
534     }
535 
536     bool succ = false;
537     unique_ptr<char[]> path;
538     tie(succ, path, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8StringPath();
539     if (!succ) {
540         UniError(EINVAL).ThrowErr(env, "Invalid path");
541         return nullptr;
542     }
543 
544     if (unlink(path.get()) == -1) {
545         UniError(errno).ThrowErr(env);
546         return nullptr;
547     }
548 
549     return NVal::CreateUndefined(env).val_;
550 }
551 
WriteSync(napi_env env,napi_callback_info info)552 napi_value PropNExporter::WriteSync(napi_env env, napi_callback_info info)
553 {
554     NFuncArg funcArg(env, info);
555     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
556         UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
557         return nullptr;
558     }
559 
560     bool succ = false;
561     int fd = -1;
562     tie(succ, fd) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
563     if (!succ || fd < 0) {
564         UniError(EINVAL).ThrowErr(env, "Invalid fd");
565         return nullptr;
566     }
567 
568     void *buf = nullptr;
569     size_t len = 0;
570     int64_t position = -1;
571     unique_ptr<char[]> bufGuard = nullptr;
572     tie(succ, bufGuard, buf, len, position) =
573         CommonFunc::GetWriteArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
574     if (!succ) {
575         return nullptr;
576     }
577 
578     ssize_t writeLen = 0;
579     if (position >= 0) {
580         writeLen = pwrite(fd, buf, len, position);
581     } else {
582         writeLen = write(fd, buf, len);
583     }
584 
585     if (writeLen == -1) {
586         UniError(errno).ThrowErr(env);
587         return nullptr;
588     }
589 
590     return NVal::CreateInt64(env, writeLen).val_;
591 }
592 
ExportSync()593 bool PropNExporter::ExportSync()
594 {
595     return exports_.AddProp({
596         NVal::DeclareNapiFunction("accessSync", AccessSync),
597         NVal::DeclareNapiFunction("chmodSync", Chmod::Sync),
598         NVal::DeclareNapiFunction("chownSync", Chown::Sync),
599         NVal::DeclareNapiFunction("closeSync", Close::Sync),
600         NVal::DeclareNapiFunction("copyFileSync", CopyFile::Sync),
601         NVal::DeclareNapiFunction("createStreamSync", CreateStream::Sync),
602         NVal::DeclareNapiFunction("fchmodSync", Fchmod::Sync),
603         NVal::DeclareNapiFunction("fchownSync", Fchown::Sync),
604         NVal::DeclareNapiFunction("fdatasyncSync", Fdatasync::Sync),
605         NVal::DeclareNapiFunction("fdopenStreamSync", FdopenStream::Sync),
606         NVal::DeclareNapiFunction("fstatSync", Fstat::Sync),
607         NVal::DeclareNapiFunction("fsyncSync", Fsync::Sync),
608         NVal::DeclareNapiFunction("ftruncateSync", Ftruncate::Sync),
609         NVal::DeclareNapiFunction("lchownSync", Lchown::Sync),
610         NVal::DeclareNapiFunction("linkSync", Link::Sync),
611         NVal::DeclareNapiFunction("lseekSync", Lseek::Sync),
612         NVal::DeclareNapiFunction("lstatSync", Lstat::Sync),
613         NVal::DeclareNapiFunction("mkdirSync", MkdirSync),
614         NVal::DeclareNapiFunction("mkdtempSync", Mkdtemp::Sync),
615         NVal::DeclareNapiFunction("openSync", Open::Sync),
616         NVal::DeclareNapiFunction("opendirSync", OpenDir::Sync),
617         NVal::DeclareNapiFunction("readdirSync", ReadDir::Sync),
618         NVal::DeclareNapiFunction("posixFallocateSync", PosixFallocate::Sync),
619         NVal::DeclareNapiFunction("readSync", ReadSync),
620         NVal::DeclareNapiFunction("readTextSync", ReadText::Sync),
621         NVal::DeclareNapiFunction("renameSync", Rename::Sync),
622         NVal::DeclareNapiFunction("rmdirSync", Rmdirent::Sync),
623         NVal::DeclareNapiFunction("statSync", Stat::Sync),
624         NVal::DeclareNapiFunction("symlinkSync", Symlink::Sync),
625         NVal::DeclareNapiFunction("truncateSync", Truncate::Sync),
626         NVal::DeclareNapiFunction("unlinkSync", UnlinkSync),
627         NVal::DeclareNapiFunction("writeSync", WriteSync),
628     });
629 }
630 
ExportAsync()631 bool PropNExporter::ExportAsync()
632 {
633     return exports_.AddProp({
634         NVal::DeclareNapiFunction("access", Access),
635         NVal::DeclareNapiFunction("access", Access),
636         NVal::DeclareNapiFunction("chmod", Chmod::Async),
637         NVal::DeclareNapiFunction("chown", Chown::Async),
638         NVal::DeclareNapiFunction("close", Close::Async),
639         NVal::DeclareNapiFunction("copyFile", CopyFile::Async),
640         NVal::DeclareNapiFunction("createStream", CreateStream::Async),
641         NVal::DeclareNapiFunction("createWatcher", Watcher::CreateWatcher),
642         NVal::DeclareNapiFunction("fchmod", Fchmod::Async),
643         NVal::DeclareNapiFunction("fchown", Fchown::Async),
644         NVal::DeclareNapiFunction("fdatasync", Fdatasync::Async),
645         NVal::DeclareNapiFunction("fdopenStream", FdopenStream::Async),
646         NVal::DeclareNapiFunction("fstat", Fstat::Async),
647         NVal::DeclareNapiFunction("fsync", Fsync::Async),
648         NVal::DeclareNapiFunction("ftruncate", Ftruncate::Async),
649         NVal::DeclareNapiFunction("hash", Hash::Async),
650         NVal::DeclareNapiFunction("lchown", Lchown::Async),
651         NVal::DeclareNapiFunction("link", Link::Async),
652         NVal::DeclareNapiFunction("lseek", Lseek::Async),
653         NVal::DeclareNapiFunction("lstat", Lstat::Async),
654         NVal::DeclareNapiFunction("mkdir", Mkdir),
655         NVal::DeclareNapiFunction("mkdtemp", Mkdtemp::Async),
656         NVal::DeclareNapiFunction("open", Open::Async),
657         NVal::DeclareNapiFunction("opendir", OpenDir::Async),
658         NVal::DeclareNapiFunction("readdir", ReadDir::Async),
659         NVal::DeclareNapiFunction("posixFallocate", PosixFallocate::Async),
660         NVal::DeclareNapiFunction("read", Read),
661         NVal::DeclareNapiFunction("readText", ReadText::Async),
662         NVal::DeclareNapiFunction("rename", Rename::Async),
663         NVal::DeclareNapiFunction("rmdir", Rmdirent::Async),
664         NVal::DeclareNapiFunction("stat", Stat::Async),
665         NVal::DeclareNapiFunction("symlink", Symlink::Async),
666         NVal::DeclareNapiFunction("truncate", Truncate::Async),
667         NVal::DeclareNapiFunction("unlink", Unlink),
668         NVal::DeclareNapiFunction("write", Write),
669     });
670 }
671 
Export()672 bool PropNExporter::Export()
673 {
674     return ExportSync() && ExportAsync();
675 }
676 
GetClassName()677 string PropNExporter::GetClassName()
678 {
679     return PropNExporter::className_;
680 }
681 
PropNExporter(napi_env env,napi_value exports)682 PropNExporter::PropNExporter(napi_env env, napi_value exports) : NExporter(env, exports) {}
683 } // namespace ModuleFileIO
684 } // namespace DistributedFS
685 } // namespace OHOS
686