1 /*
2 * Copyright (c) 2021 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 "device_sm_exporter.h"
17
18 #include <cerrno>
19 #include <climits>
20 #include <cstdio>
21 #include <cstdlib>
22 #include <cstring>
23 #include <dirent.h>
24 #include <fcntl.h>
25 #include <stack>
26 #include <sys/sendfile.h>
27 #include <sys/stat.h>
28 #include <sys/types.h>
29 #include <vector>
30
31 #include "../common/ability_helper.h"
32 #include "../common/common_func.h"
33 #include "../common/napi/n_class.h"
34 #include "../common/napi/n_func_arg.h"
35 #include "../common/napi/n_val.h"
36 #include "../common/uni_error.h"
37 #include "device_storage_manager.h"
38
39 using Uri = OHOS::Uri;
40 using namespace std;
41 namespace OHOS {
42 namespace DistributedFS {
43 namespace ModuleDSMExpoter {
44 enum COMMON_NUM {
45 ZERO = 0,
46 ONE = 1,
47 TWO = 2,
48 THREE = 3,
49 };
50 const int ERROR = 300;
51 const int NULL_ERROR = 202;
52
ForeachVomInfos(std::vector<std::shared_ptr<OHOS::DS::VolumeInfo>> & infos,napi_env & env,napi_value & getvolumenapi,int32_t & userId)53 static void ForeachVomInfos(std::vector<std::shared_ptr<OHOS::DS::VolumeInfo>> &infos,
54 napi_env &env,
55 napi_value &getvolumenapi,
56 int32_t &userId)
57 {
58 int32_t i = 0;
59
60 for (auto vomInfo : infos) {
61 NVal objv = NVal::CreateObject(env);
62 objv.AddProp("mId", NVal::CreateUTF8String(env, vomInfo->GetId()).val_);
63 objv.AddProp("mDiskId", NVal::CreateUTF8String(env, vomInfo->GetDiskId()).val_);
64 objv.AddProp("mPartGuid", NVal::CreateUTF8String(env, vomInfo->GetPartGuid()).val_);
65 objv.AddProp("mFsUuid", NVal::CreateUTF8String(env, vomInfo->GetFsUuid()).val_);
66 objv.AddProp("mType", NVal::CreateInt64(env, vomInfo->GetType()).val_);
67 objv.AddProp("mMountFlags", NVal::CreateInt64(env, vomInfo->GetMountFlags()).val_);
68 objv.AddProp("mMountUserId", NVal::CreateInt64(env, vomInfo->GetMountUserId()).val_);
69 objv.AddProp("mState", NVal::CreateInt64(env, vomInfo->GetState()).val_);
70 objv.AddProp("mPath", NVal::CreateUTF8String(env, vomInfo->GetPath()).val_);
71 objv.AddProp("mInternalPath", NVal::CreateUTF8String(env, vomInfo->GetInternalPath()).val_);
72 objv.AddProp("mFsLabel", NVal::CreateUTF8String(env, vomInfo->GetFsLabel()).val_);
73 objv.AddProp("IsEmulated", NVal::CreateBool(env, vomInfo->IsEmulated()).val_);
74 objv.AddProp("IsPrimaryEmulatedForUser",
75 NVal::CreateBool(env, vomInfo->IsPrimaryEmulatedForUser(userId)).val_);
76 objv.AddProp("IsRemovable", NVal::CreateBool(env, vomInfo->IsRemovable(userId)).val_);
77 objv.AddProp("IsPrimary", NVal::CreateBool(env, vomInfo->IsPrimary()).val_);
78 objv.AddProp("Description", NVal::CreateUTF8String(env, vomInfo->GetDescription()).val_);
79 objv.AddProp("IsVisibleForUser", NVal::CreateBool(env, vomInfo->IsVisibleForUser(userId)).val_);
80
81 napi_set_property(env, getvolumenapi, NVal::CreateInt32(env, i).val_, objv.val_);
82 i++;
83 }
84 }
85
ForeachDsmInfos(std::vector<std::shared_ptr<OHOS::DS::DiskInfo>> & infos,napi_env & env,napi_value & diaknapi)86 static void ForeachDsmInfos(std::vector<std::shared_ptr<OHOS::DS::DiskInfo>> &infos,
87 napi_env &env,
88 napi_value &diaknapi)
89 {
90 int32_t i = 0;
91
92 for (auto dsmInfo : infos) {
93 NVal objt = NVal::CreateObject(env);
94 objt.AddProp("mId", NVal::CreateUTF8String(env, dsmInfo->GetId()).val_);
95 objt.AddProp("mSysPath", NVal::CreateUTF8String(env, dsmInfo->GetSysPath()).val_);
96 objt.AddProp("mSize", NVal::CreateInt64(env, dsmInfo->GetSize()).val_);
97 objt.AddProp("mLabel", NVal::CreateUTF8String(env, dsmInfo->GetLabel()).val_);
98 objt.AddProp("mFlags", NVal::CreateInt64(env, dsmInfo->GetFlags()).val_);
99 objt.AddProp("IsUsb", NVal::CreateBool(env, dsmInfo->IsUsb()).val_);
100 objt.AddProp("IsSd", NVal::CreateBool(env, dsmInfo->IsSd()).val_);
101 objt.AddProp("IsAdoptable", NVal::CreateBool(env, dsmInfo->IsAdoptable()).val_);
102 objt.AddProp("Description", NVal::CreateUTF8String(env, dsmInfo->GetDescription()).val_);
103
104 napi_set_property(env, diaknapi, NVal::CreateInt32(env, i).val_, objt.val_);
105 i++;
106 }
107 }
108
CallBackSuccess(napi_env env,napi_ref successFuncRef,int32_t count,napi_value obj)109 void CallBackSuccess(napi_env env, napi_ref successFuncRef, int32_t count, napi_value obj)
110 {
111 napi_value results = nullptr;
112 napi_value successFunc = nullptr;
113 napi_value global = nullptr;
114 napi_get_global(env, &global);
115 napi_get_reference_value(env, successFuncRef, &successFunc);
116 if (successFunc == nullptr) {
117 return;
118 }
119 napi_call_function(env, global, successFunc, count, &obj, &results);
120 }
CallBackError(napi_env env,napi_ref failFuncRef,string errorProp,int errorCode)121 void CallBackError(napi_env env, napi_ref failFuncRef, string errorProp, int errorCode)
122 {
123 napi_value argvFail[2] = { 0 };
124 napi_value results = nullptr;
125 napi_value failFunc = nullptr;
126 napi_value global = nullptr;
127 napi_get_global(env, &global);
128 argvFail[0] = NVal::CreateUTF8String(env, errorProp).val_;
129 argvFail[1] = NVal::CreateInt32(env, errorCode).val_;
130 napi_get_reference_value(env, failFuncRef, &failFunc);
131 if (failFunc == nullptr) {
132 return;
133 }
134 napi_call_function(env, global, failFunc, COMMON_NUM::TWO, argvFail, &results);
135 }
CallComplete(napi_env env,napi_ref completeFuncRef)136 void CallComplete(napi_env env, napi_ref completeFuncRef)
137 {
138 napi_value completeFunc = nullptr;
139 napi_value results = nullptr;
140 napi_value global = nullptr;
141 napi_get_global(env, &global);
142 napi_get_reference_value(env, completeFuncRef, &completeFunc);
143 if (completeFunc == nullptr) {
144 return;
145 }
146 napi_call_function(env, global, completeFunc, COMMON_NUM::ZERO, nullptr, &results);
147 }
148
149 std::shared_ptr<DeviceStorageManager> dsm = DelayedSingleton<DeviceStorageManager>::GetInstance();
150 int32_t userId;
VolumesToNapi(napi_env env,std::vector<std::shared_ptr<DS::VolumeInfo>> infos)151 napi_value VolumesToNapi(napi_env env, std::vector<std::shared_ptr<DS::VolumeInfo>> infos)
152 {
153 napi_value getvolumenapi;
154 napi_create_array(env, &getvolumenapi);
155 ForeachVomInfos(infos, env, getvolumenapi, userId);
156 return getvolumenapi;
157 }
158
PriVolToEmuVol(napi_env env,NVal a,std::shared_ptr<DS::VolumeInfo> & emuVol)159 void PriVolToEmuVol(napi_env env, NVal a, std::shared_ptr<DS::VolumeInfo> &emuVol)
160 {
161 bool succ = false;
162
163 unique_ptr<char[]> id = nullptr;
164 tie(succ, id, ignore) = a.GetProp("mId").ToUTF8String();
165 string cId = (id == nullptr) ? "" : id.get();
166 emuVol->SetId(cId);
167
168 unique_ptr<char[]> diskId = nullptr;
169 tie(succ, diskId, ignore) = a.GetProp("mDiskId").ToUTF8String();
170 emuVol->SetDiskId((diskId == nullptr) ? "" : diskId.get());
171
172 int64_t type = 0;
173 tie(succ, type) = a.GetProp("mType").ToInt64();
174 emuVol->SetType(type);
175
176 unique_ptr<char[]> partGuid = nullptr;
177 tie(succ, partGuid, ignore) = a.GetProp("mPartGuid").ToUTF8String();
178 emuVol->SetPartGuid((partGuid == nullptr) ? "" : partGuid.get());
179
180 int64_t mountFlags = 0;
181 tie(succ, mountFlags) = a.GetProp("mMountFlags").ToInt64();
182 emuVol->SetMountFlags(mountFlags);
183
184 int64_t mountUserId = 0;
185 tie(succ, mountUserId) = a.GetProp("mMountUserId").ToInt64();
186 emuVol->SetMountUserId(mountUserId);
187
188 unique_ptr<char[]> path = nullptr;
189 tie(succ, path, ignore) = a.GetProp("mPath").ToUTF8String();
190 emuVol->SetPath((path == nullptr) ? "" : path.get());
191
192 unique_ptr<char[]> internalPath = nullptr;
193 tie(succ, internalPath, ignore) = a.GetProp("mInternalPath").ToUTF8String();
194 emuVol->SetInternalPath((internalPath == nullptr) ? "" : internalPath.get());
195
196 unique_ptr<char[]> fsType = nullptr;
197 tie(succ, fsType, ignore) = a.GetProp("mFsType").ToUTF8String();
198 emuVol->SetFsUuid((fsType == nullptr) ? "" : fsType.get());
199
200 unique_ptr<char[]> fsUuid = nullptr;
201 tie(succ, fsUuid, ignore) = a.GetProp("mFsUuid").ToUTF8String();
202 emuVol->SetFsUuid((fsUuid == nullptr) ? "" : fsUuid.get());
203
204 unique_ptr<char[]> fsLabel = nullptr;
205 tie(succ, fsLabel, ignore) = a.GetProp("mFsLabel").ToUTF8String();
206 string tId = (fsLabel == nullptr) ? "" : fsLabel.get();
207 emuVol->SetFsLabel(tId);
208
209 int64_t state = 0;
210 tie(succ, state) = a.GetProp("mState").ToInt64();
211 emuVol->SetState(state);
212 }
213
EmuVolToPriVol(napi_env env,NVal a,std::shared_ptr<DS::VolumeInfo> & priVol)214 void EmuVolToPriVol(napi_env env, NVal a, std::shared_ptr<DS::VolumeInfo> &priVol)
215 {
216 bool succ = false;
217
218 unique_ptr<char[]> id = nullptr;
219 tie(succ, id, ignore) = a.GetProp("mId").ToUTF8String();
220 string cId = (id == nullptr) ? "" : id.get();
221 priVol->SetId(cId);
222
223 unique_ptr<char[]> diskId = nullptr;
224 tie(succ, diskId, ignore) = a.GetProp("mDiskId").ToUTF8String();
225 priVol->SetDiskId((diskId == nullptr) ? "" : diskId.get());
226
227 int64_t type = 0;
228 tie(succ, type) = a.GetProp("mType").ToInt64();
229 priVol->SetType(type);
230
231 unique_ptr<char[]> partGuid = nullptr;
232 tie(succ, partGuid, ignore) = a.GetProp("mPartGuid").ToUTF8String();
233 priVol->SetPartGuid((partGuid == nullptr) ? "" : partGuid.get());
234
235 int64_t mountFlags = 0;
236 tie(succ, mountFlags) = a.GetProp("mMountFlags").ToInt64();
237 priVol->SetMountFlags(mountFlags);
238
239 int64_t mountUserId = 0;
240 tie(succ, mountUserId) = a.GetProp("mMountUserId").ToInt64();
241 priVol->SetMountUserId(mountUserId);
242
243 unique_ptr<char[]> path = nullptr;
244 tie(succ, path, ignore) = a.GetProp("mPath").ToUTF8String();
245 priVol->SetPath((path == nullptr) ? "" : path.get());
246
247 unique_ptr<char[]> internalPath = nullptr;
248 tie(succ, internalPath, ignore) = a.GetProp("mInternalPath").ToUTF8String();
249 priVol->SetInternalPath((internalPath == nullptr) ? "" : internalPath.get());
250
251 unique_ptr<char[]> fsType = nullptr;
252 tie(succ, fsType, ignore) = a.GetProp("mFsType").ToUTF8String();
253 priVol->SetFsUuid((fsType == nullptr) ? "" : fsType.get());
254
255 unique_ptr<char[]> fsUuid = nullptr;
256 tie(succ, fsUuid, ignore) = a.GetProp("mFsUuid").ToUTF8String();
257 priVol->SetFsUuid((fsUuid == nullptr) ? "" : fsUuid.get());
258
259 unique_ptr<char[]> fsLabel = nullptr;
260 tie(succ, fsLabel, ignore) = a.GetProp("mFsLabel").ToUTF8String();
261 string tId = (fsLabel == nullptr) ? "" : fsLabel.get();
262 priVol->SetFsLabel(tId);
263
264 int64_t state = 0;
265 tie(succ, state) = a.GetProp("mState").ToInt64();
266 priVol->SetState(state);
267 }
268
VolToDesCription(napi_env env,NVal a,std::shared_ptr<DS::VolumeInfo> & vol)269 void VolToDesCription(napi_env env, NVal a, std::shared_ptr<DS::VolumeInfo> &vol)
270 {
271 bool succ = false;
272
273 unique_ptr<char[]> id = nullptr;
274 tie(succ, id, ignore) = a.GetProp("mId").ToUTF8String();
275 string cId = (id == nullptr) ? "" : id.get();
276 vol->SetId(cId);
277
278 unique_ptr<char[]> diskId = nullptr;
279 tie(succ, diskId, ignore) = a.GetProp("mDiskId").ToUTF8String();
280 vol->SetDiskId((diskId == nullptr) ? "" : diskId.get());
281
282 int64_t type = 0;
283 tie(succ, type) = a.GetProp("mType").ToInt64();
284 vol->SetType(type);
285
286 unique_ptr<char[]> partGuid = nullptr;
287 tie(succ, partGuid, ignore) = a.GetProp("mPartGuid").ToUTF8String();
288 vol->SetPartGuid((partGuid == nullptr) ? "" : partGuid.get());
289
290 int64_t mountFlags = 0;
291 tie(succ, mountFlags) = a.GetProp("mMountFlags").ToInt64();
292 vol->SetMountFlags(mountFlags);
293
294 int64_t mountUserId = 0;
295 tie(succ, mountUserId) = a.GetProp("mMountUserId").ToInt64();
296 vol->SetMountUserId(mountUserId);
297
298 unique_ptr<char[]> path = nullptr;
299 tie(succ, path, ignore) = a.GetProp("mPath").ToUTF8String();
300 vol->SetPath((path == nullptr) ? "" : path.get());
301
302 unique_ptr<char[]> internalPath = nullptr;
303 tie(succ, internalPath, ignore) = a.GetProp("mInternalPath").ToUTF8String();
304 vol->SetInternalPath((internalPath == nullptr) ? "" : internalPath.get());
305
306 unique_ptr<char[]> fsType = nullptr;
307 tie(succ, fsType, ignore) = a.GetProp("mFsType").ToUTF8String();
308 vol->SetFsUuid((fsType == nullptr) ? "" : fsType.get());
309
310 unique_ptr<char[]> fsUuid = nullptr;
311 tie(succ, fsUuid, ignore) = a.GetProp("mFsUuid").ToUTF8String();
312 vol->SetFsUuid((fsUuid == nullptr) ? "" : fsUuid.get());
313
314 unique_ptr<char[]> fsLabel = nullptr;
315 tie(succ, fsLabel, ignore) = a.GetProp("mFsLabel").ToUTF8String();
316 string tId = (fsLabel == nullptr) ? "" : fsLabel.get();
317 vol->SetFsLabel(tId);
318
319 int64_t state = 0;
320 tie(succ, state) = a.GetProp("mState").ToInt64();
321 vol->SetState(state);
322 }
323
Mount(napi_env env,napi_callback_info info)324 napi_value DeviceSMExporter::Mount(napi_env env, napi_callback_info info)
325 {
326 NFuncArg funcArg(env, info);
327 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
328 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
329 return nullptr;
330 }
331 bool succ = false;
332 napi_ref napiSuccFun, napiCompFun, napiFailFun;
333 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
334 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
335
336 unique_ptr<char[]> deviceId = nullptr;
337 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("volId").ToUTF8String();
338
339 std::string mvId = (deviceId == nullptr) ? "" : deviceId.get();
340 if (mvId == "") {
341 CallBackError(env, napiFailFun, "Mount incoming parameter is null", NULL_ERROR);
342 CallComplete(env, napiCompFun);
343 napi_delete_reference(env, napiSuccFun);
344 napi_delete_reference(env, napiFailFun);
345 napi_delete_reference(env, napiCompFun);
346 return nullptr;
347 }
348
349 bool s = dsm->Mount(mvId);
350 if (s) {
351 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
352 } else {
353 CallBackError(env, napiFailFun, "Mount return value error", ERROR);
354 }
355 CallComplete(env, napiCompFun);
356 napi_delete_reference(env, napiSuccFun);
357 napi_delete_reference(env, napiFailFun);
358 napi_delete_reference(env, napiCompFun);
359 return NVal::CreateUndefined(env).val_;
360 }
361
UnMount(napi_env env,napi_callback_info info)362 napi_value DeviceSMExporter::UnMount(napi_env env, napi_callback_info info)
363 {
364 NFuncArg funcArg(env, info);
365 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
366 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
367 return nullptr;
368 }
369 bool succ = false;
370 napi_ref napiSuccFun, napiCompFun, napiFailFun;
371 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
372 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
373
374 unique_ptr<char[]> deviceId = nullptr;
375 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("volId").ToUTF8String();
376
377 std::string mvId = (deviceId == nullptr) ? "" : deviceId.get();
378 if (mvId == "") {
379 CallBackError(env, napiFailFun, "UnMount incoming parameter is null", NULL_ERROR);
380 CallComplete(env, napiCompFun);
381 napi_delete_reference(env, napiSuccFun);
382 napi_delete_reference(env, napiFailFun);
383 napi_delete_reference(env, napiCompFun);
384 return nullptr;
385 }
386
387 bool s = dsm->UnMount(mvId);
388 if (s) {
389 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
390 } else {
391 CallBackError(env, napiFailFun, "UnMount return value error", ERROR);
392 }
393
394 CallComplete(env, napiCompFun);
395 napi_delete_reference(env, napiSuccFun);
396 napi_delete_reference(env, napiFailFun);
397 napi_delete_reference(env, napiCompFun);
398 return NVal::CreateUndefined(env).val_;
399 }
400
Format(napi_env env,napi_callback_info info)401 napi_value DeviceSMExporter::Format(napi_env env, napi_callback_info info)
402 {
403 NFuncArg funcArg(env, info);
404 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
405 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
406 return nullptr;
407 }
408 bool succ = false;
409 napi_ref napiSuccFun, napiCompFun, napiFailFun;
410 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
411 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
412
413 unique_ptr<char[]> deviceId = nullptr;
414 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("volId").ToUTF8String();
415
416 std::string mvId = (deviceId == nullptr) ? "" : deviceId.get();
417 if (mvId == "") {
418 CallBackError(env, napiFailFun, "Format incoming parameter is null", NULL_ERROR);
419 CallComplete(env, napiCompFun);
420 napi_delete_reference(env, napiSuccFun);
421 napi_delete_reference(env, napiFailFun);
422 napi_delete_reference(env, napiCompFun);
423 return nullptr;
424 }
425
426 bool s = dsm->Format(mvId);
427 if (s) {
428 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
429 } else {
430 CallBackError(env, napiFailFun, "Format fail", ERROR);
431 }
432
433 CallComplete(env, napiCompFun);
434 napi_delete_reference(env, napiSuccFun);
435 napi_delete_reference(env, napiFailFun);
436 napi_delete_reference(env, napiCompFun);
437 return NVal::CreateUndefined(env).val_;
438 }
439
IsEncrypted(napi_env env,napi_callback_info info)440 napi_value DeviceSMExporter::IsEncrypted(napi_env env, napi_callback_info info)
441 {
442 NFuncArg funcArg(env, info);
443 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
444 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
445 return nullptr;
446 }
447 bool succ = false;
448 napi_ref napiSuccFun, napiCompFun, napiFailFun;
449 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
450 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
451
452 unique_ptr<char[]> devfilePath = nullptr;
453 tie(succ, devfilePath, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("filePath").ToUTF8String();
454
455 std::string mFilePath = (devfilePath == nullptr) ? "" : devfilePath.get();
456 if (mFilePath == "") {
457 CallBackError(env, napiFailFun, "IsEncrypted incoming parameter is null", NULL_ERROR);
458 CallComplete(env, napiCompFun);
459 napi_delete_reference(env, napiSuccFun);
460 napi_delete_reference(env, napiFailFun);
461 napi_delete_reference(env, napiCompFun);
462 return nullptr;
463 }
464
465 bool s = dsm->IsEncrypted(mFilePath);
466 if (s) {
467 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
468 } else {
469 CallBackError(env, napiFailFun, "Not A Encrypted Path", ERROR);
470 }
471
472 CallComplete(env, napiCompFun);
473 napi_delete_reference(env, napiSuccFun);
474 napi_delete_reference(env, napiFailFun);
475 napi_delete_reference(env, napiCompFun);
476 return NVal::CreateUndefined(env).val_;
477 }
PartitionPublic(napi_env env,napi_callback_info info)478 napi_value DeviceSMExporter::PartitionPublic(napi_env env, napi_callback_info info)
479 {
480 NFuncArg funcArg(env, info);
481 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
482 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
483 return nullptr;
484 }
485 bool succ = false;
486 napi_ref napiSuccFun, napiCompFun, napiFailFun;
487 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
488 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
489
490 unique_ptr<char[]> deviceId = nullptr;
491 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("diskId").ToUTF8String();
492
493 std::string dsId = (deviceId == nullptr) ? "" : deviceId.get();
494 if (dsId == "") {
495 CallBackError(env, napiFailFun, "PartitionPublic incoming parameter is null", NULL_ERROR);
496 CallComplete(env, napiCompFun);
497 napi_delete_reference(env, napiSuccFun);
498 napi_delete_reference(env, napiFailFun);
499 napi_delete_reference(env, napiCompFun);
500 return nullptr;
501 }
502
503 bool s = dsm->PartitionPublic(dsId);
504 if (s) {
505 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
506 } else {
507 CallBackError(env, napiFailFun, "PartitionPublic fail", ERROR);
508 }
509
510 CallComplete(env, napiCompFun);
511 napi_delete_reference(env, napiSuccFun);
512 napi_delete_reference(env, napiFailFun);
513 napi_delete_reference(env, napiCompFun);
514 return NVal::CreateUndefined(env).val_;
515 }
516
PartitionPrivate(napi_env env,napi_callback_info info)517 napi_value DeviceSMExporter::PartitionPrivate(napi_env env, napi_callback_info info)
518 {
519 NFuncArg funcArg(env, info);
520 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
521 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
522 return nullptr;
523 }
524 bool succ = false;
525 napi_ref napiSuccFun, napiCompFun, napiFailFun;
526 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
527 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
528
529 unique_ptr<char[]> deviceId = nullptr;
530 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("diskId").ToUTF8String();
531
532 std::string dsId = (deviceId == nullptr) ? "" : deviceId.get();
533 if (dsId == "") {
534 CallBackError(env, napiFailFun, "PartitionPrivate incoming parameter is null", NULL_ERROR);
535 CallComplete(env, napiCompFun);
536 napi_delete_reference(env, napiSuccFun);
537 napi_delete_reference(env, napiFailFun);
538 napi_delete_reference(env, napiCompFun);
539 return nullptr;
540 }
541
542 bool s = dsm->PartitionPrivate(dsId);
543 if (s) {
544 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
545 } else {
546 CallBackError(env, napiFailFun, "PartitionPrivate fail", ERROR);
547 }
548
549 CallComplete(env, napiCompFun);
550 napi_delete_reference(env, napiSuccFun);
551 napi_delete_reference(env, napiFailFun);
552 napi_delete_reference(env, napiCompFun);
553 return NVal::CreateUndefined(env).val_;
554 }
555
GetVolumes(napi_env env,napi_callback_info info)556 napi_value DeviceSMExporter::GetVolumes(napi_env env, napi_callback_info info)
557 {
558 NFuncArg funcArg(env, info);
559 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
560 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
561 return nullptr;
562 }
563 bool succ = false;
564 napi_ref napiSuccFun, napiCompFun, napiFailFun;
565 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
566 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
567
568 std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
569 bool ret = dsm->GetVolumes(infos);
570 if (ret) {
571 napi_value getvolumenapi = VolumesToNapi(env, infos);
572
573 NVal objc = NVal::CreateObject(env);
574 objc.AddProp("volumeInfos", getvolumenapi);
575 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
576 } else {
577 CallBackError(env, napiFailFun, "getvolume not exist", ERROR);
578 }
579
580 CallComplete(env, napiCompFun);
581 napi_delete_reference(env, napiSuccFun);
582 napi_delete_reference(env, napiFailFun);
583 napi_delete_reference(env, napiCompFun);
584 return NVal::CreateUndefined(env).val_;
585 }
586
GetDisks(napi_env env,napi_callback_info info)587 napi_value DeviceSMExporter::GetDisks(napi_env env, napi_callback_info info)
588 {
589 NFuncArg funcArg(env, info);
590 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
591 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
592 return nullptr;
593 }
594 bool succ = false;
595 napi_ref napiSuccFun, napiCompFun, napiFailFun;
596 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
597 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
598
599 std::vector<std::shared_ptr<DS::DiskInfo>> infos;
600 bool ret = dsm->GetDisks(infos);
601 if (ret) {
602 napi_value diaknapi;
603 napi_create_array(env, &diaknapi);
604 ForeachDsmInfos(infos, env, diaknapi);
605 NVal objn = NVal::CreateObject(env);
606 objn.AddProp("diskInfos", diaknapi);
607 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objn.val_);
608 } else {
609 CallBackError(env, napiFailFun, "disk not exist", ERROR);
610 }
611
612 CallComplete(env, napiCompFun);
613 napi_delete_reference(env, napiSuccFun);
614 napi_delete_reference(env, napiFailFun);
615 napi_delete_reference(env, napiCompFun);
616 return NVal::CreateUndefined(env).val_;
617 }
618
SetPrimaryStorageUuid(napi_env env,napi_callback_info info)619 napi_value DeviceSMExporter::SetPrimaryStorageUuid(napi_env env, napi_callback_info info)
620 {
621 NFuncArg funcArg(env, info);
622 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
623 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
624 return nullptr;
625 }
626 bool succ = false;
627 napi_ref napiSuccFun, napiCompFun, napiFailFun;
628 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
629 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
630
631 unique_ptr<char[]> deviceId = nullptr;
632 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("volumeUuid").ToUTF8String();
633 std::string vuId = (deviceId == nullptr) ? "" : deviceId.get();
634 if (vuId == "") {
635 CallBackError(env, napiFailFun, "SetPrimaryStorageUuid incoming parameter is null", NULL_ERROR);
636 CallComplete(env, napiCompFun);
637 napi_delete_reference(env, napiSuccFun);
638 napi_delete_reference(env, napiFailFun);
639 napi_delete_reference(env, napiCompFun);
640 return nullptr;
641 }
642
643 bool s = dsm->SetPrimaryStorageUuid(vuId);
644 if (s) {
645 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ZERO, nullptr);
646 } else {
647 CallBackError(env, napiFailFun, "SetPrimaryStorageUuid fail", ERROR);
648 }
649
650 CallComplete(env, napiCompFun);
651 napi_delete_reference(env, napiSuccFun);
652 napi_delete_reference(env, napiFailFun);
653 napi_delete_reference(env, napiCompFun);
654 return NVal::CreateUndefined(env).val_;
655 }
656
FindVolumeById(napi_env env,napi_callback_info info)657 napi_value DeviceSMExporter::FindVolumeById(napi_env env, napi_callback_info info)
658 {
659 NFuncArg funcArg(env, info);
660 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
661 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
662 return nullptr;
663 }
664 bool succ = false;
665 napi_ref napiSuccFun, napiCompFun, napiFailFun;
666 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
667 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
668
669 unique_ptr<char[]> deviceId = nullptr;
670 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("volId").ToUTF8String();
671
672 std::string mvId = (deviceId == nullptr) ? "" : deviceId.get();
673 if (mvId == "") {
674 CallBackError(env, napiFailFun, "FindVolumeById incoming parameter is null", NULL_ERROR);
675 CallComplete(env, napiCompFun);
676 napi_delete_reference(env, napiSuccFun);
677 napi_delete_reference(env, napiFailFun);
678 napi_delete_reference(env, napiCompFun);
679 return nullptr;
680 }
681
682 std::shared_ptr<DS::VolumeInfo> vol;
683 bool ret = dsm->FindVolumeById(vol, mvId);
684 if (ret) {
685 napi_value getvolumenapi;
686 napi_create_array(env, &getvolumenapi);
687 std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
688 dsm->GetVolumes(infos);
689 ForeachVomInfos(infos, env, getvolumenapi, userId);
690 NVal objc = NVal::CreateObject(env);
691 objc.AddProp("volumeInfos", getvolumenapi);
692 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
693 } else {
694 CallBackError(env, napiFailFun, "FindVolumeById not exist", ERROR);
695 }
696
697 CallComplete(env, napiCompFun);
698 napi_delete_reference(env, napiSuccFun);
699 napi_delete_reference(env, napiFailFun);
700 napi_delete_reference(env, napiCompFun);
701 return NVal::CreateUndefined(env).val_;
702 }
703
FindVolumeByUuid(napi_env env,napi_callback_info info)704 napi_value DeviceSMExporter::FindVolumeByUuid(napi_env env, napi_callback_info info)
705 {
706 NFuncArg funcArg(env, info);
707 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
708 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
709 return nullptr;
710 }
711 bool succ = false;
712 napi_ref napiSuccFun, napiCompFun, napiFailFun;
713 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
714 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
715
716 unique_ptr<char[]> deviceId = nullptr;
717 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("volumeUuid").ToUTF8String();
718
719 std::string mvmId = (deviceId == nullptr) ? "" : deviceId.get();
720 if (mvmId == "") {
721 CallBackError(env, napiFailFun, "FindVolumeByUuid incoming parameter is null", NULL_ERROR);
722 CallComplete(env, napiCompFun);
723 napi_delete_reference(env, napiSuccFun);
724 napi_delete_reference(env, napiFailFun);
725 napi_delete_reference(env, napiCompFun);
726 return nullptr;
727 }
728
729 std::shared_ptr<DS::VolumeInfo> vol;
730 if (dsm->FindVolumeByUuid(vol, mvmId)) {
731 napi_value getvolumenapi;
732 napi_create_array(env, &getvolumenapi);
733 std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
734 dsm->GetVolumes(infos);
735 ForeachVomInfos(infos, env, getvolumenapi, userId);
736 NVal objc = NVal::CreateObject(env);
737 objc.AddProp("volumeInfos", getvolumenapi);
738 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
739 } else {
740 CallBackError(env, napiFailFun, "FindVolumeByUuid not exist", ERROR);
741 }
742
743 CallComplete(env, napiCompFun);
744 napi_delete_reference(env, napiSuccFun);
745 napi_delete_reference(env, napiFailFun);
746 napi_delete_reference(env, napiCompFun);
747 return NVal::CreateUndefined(env).val_;
748 }
749
FindDiskById(napi_env env,napi_callback_info info)750 napi_value DeviceSMExporter::FindDiskById(napi_env env, napi_callback_info info)
751 {
752 NFuncArg funcArg(env, info);
753 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
754 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
755 return nullptr;
756 }
757 bool succ = false;
758 napi_ref napiSuccFun, napiCompFun, napiFailFun;
759 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
760 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
761
762 unique_ptr<char[]> deviceId = nullptr;
763 tie(succ, deviceId, ignore) = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("diskId").ToUTF8String();
764
765 std::string dsId = (deviceId == nullptr) ? "" : deviceId.get();
766 if (dsId == "") {
767 CallBackError(env, napiFailFun, "FindDiskById incoming parameter is null", NULL_ERROR);
768 CallComplete(env, napiCompFun);
769 napi_delete_reference(env, napiSuccFun);
770 napi_delete_reference(env, napiFailFun);
771 napi_delete_reference(env, napiCompFun);
772 return nullptr;
773 }
774
775 std::shared_ptr<DS::DiskInfo> disk;
776 if (dsm->FindDiskById(disk, dsId)) {
777 napi_value diaknapi;
778 napi_create_array(env, &diaknapi);
779 std::vector<std::shared_ptr<DS::DiskInfo>> infos;
780 dsm->GetDisks(infos);
781 ForeachDsmInfos(infos, env, diaknapi);
782 NVal objn = NVal::CreateObject(env);
783 objn.AddProp("diskInfos", diaknapi);
784 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objn.val_);
785 } else {
786 CallBackError(env, napiFailFun, "FindDiskById not exist", ERROR);
787 }
788
789 CallComplete(env, napiCompFun);
790 napi_delete_reference(env, napiSuccFun);
791 napi_delete_reference(env, napiFailFun);
792 napi_delete_reference(env, napiCompFun);
793 return NVal::CreateUndefined(env).val_;
794 }
795
GetPrimaryStorageUuid(napi_env env,napi_callback_info info)796 napi_value DeviceSMExporter::GetPrimaryStorageUuid(napi_env env, napi_callback_info info)
797 {
798 NFuncArg funcArg(env, info);
799 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
800 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
801 return nullptr;
802 }
803 bool succ = false;
804 napi_ref napiSuccFun, napiCompFun, napiFailFun;
805 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
806 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
807
808 std::string primaryUuid;
809 bool s = dsm->GetPrimaryStorageUuid(primaryUuid);
810 if (s) {
811 NVal obj = NVal::CreateObject(env);
812 obj.AddProp("primaryUuid", NVal::CreateUTF8String(env, primaryUuid).val_);
813 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, obj.val_);
814 } else {
815 CallBackError(env, napiFailFun, "GetPrimaryStorageUuid return value error", ERROR);
816 }
817
818 CallComplete(env, napiCompFun);
819 napi_delete_reference(env, napiSuccFun);
820 napi_delete_reference(env, napiFailFun);
821 napi_delete_reference(env, napiCompFun);
822 return NVal::CreateUndefined(env).val_;
823 }
824
FindPrivateForEmulate(napi_env env,napi_callback_info info)825 napi_value DeviceSMExporter::FindPrivateForEmulate(napi_env env, napi_callback_info info)
826 {
827 NFuncArg funcArg(env, info);
828 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
829 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
830 return nullptr;
831 }
832 bool succ = false;
833 napi_ref napiSuccFun, napiCompFun, napiFailFun;
834 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
835 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
836
837 std::shared_ptr<DS::VolumeInfo> emuVol = std::make_shared<DS::VolumeInfo>();
838
839 NVal a = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("emuVol");
840 if (a.TypeIs(napi_object)) {
841 } else if (a.TypeIs(napi_undefined)) {
842 } else if (a.TypeIs(napi_null)) {
843 }
844
845 PriVolToEmuVol(env, a, emuVol);
846 std::shared_ptr<DS::VolumeInfo> priVol;
847 bool ret = dsm->FindPrivateForEmulate(priVol, emuVol);
848 if (ret) {
849 napi_value getvolumenapi;
850 napi_create_array(env, &getvolumenapi);
851 std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
852 dsm->GetVolumes(infos);
853 ForeachVomInfos(infos, env, getvolumenapi, userId);
854 NVal objc = NVal::CreateObject(env);
855 objc.AddProp("volumeInfos", getvolumenapi);
856 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
857 } else {
858 CallBackError(env, napiFailFun, "FindPrivateForEmulate not exist", ERROR);
859 }
860
861 CallComplete(env, napiCompFun);
862 napi_delete_reference(env, napiSuccFun);
863 napi_delete_reference(env, napiFailFun);
864 napi_delete_reference(env, napiCompFun);
865 return NVal::CreateUndefined(env).val_;
866 }
867
FindEmulateForPrivate(napi_env env,napi_callback_info info)868 napi_value DeviceSMExporter::FindEmulateForPrivate(napi_env env, napi_callback_info info)
869 {
870 NFuncArg funcArg(env, info);
871 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
872 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
873 return nullptr;
874 }
875 bool succ = false;
876 napi_ref napiSuccFun, napiCompFun, napiFailFun;
877 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
878 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
879
880 std::shared_ptr<DS::VolumeInfo> priVol = std::make_shared<DS::VolumeInfo>();
881
882 NVal a = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("priVol");
883 if (a.TypeIs(napi_object)) {
884 } else if (a.TypeIs(napi_undefined)) {
885 } else if (a.TypeIs(napi_null)) {
886 }
887
888 EmuVolToPriVol(env, a, priVol);
889 std::shared_ptr<DS::VolumeInfo> emuVol;
890 bool ret = dsm->FindEmulateForPrivate(emuVol, priVol);
891 if (ret) {
892 napi_value getvolumenapi;
893 napi_create_array(env, &getvolumenapi);
894 std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
895 dsm->GetVolumes(infos);
896 ForeachVomInfos(infos, env, getvolumenapi, userId);
897 NVal objc = NVal::CreateObject(env);
898 objc.AddProp("volumeInfos", getvolumenapi);
899 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
900 } else {
901 CallBackError(env, napiFailFun, "FindEmulateForPrivate not exist", ERROR);
902 }
903
904 CallComplete(env, napiCompFun);
905 napi_delete_reference(env, napiSuccFun);
906 napi_delete_reference(env, napiFailFun);
907 napi_delete_reference(env, napiCompFun);
908 return NVal::CreateUndefined(env).val_;
909 }
910
GetBestVolumeDescription(napi_env env,napi_callback_info info)911 napi_value DeviceSMExporter::GetBestVolumeDescription(napi_env env, napi_callback_info info)
912 {
913 NFuncArg funcArg(env, info);
914 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
915 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
916 return nullptr;
917 }
918 bool succ = false;
919 napi_ref napiSuccFun, napiCompFun, napiFailFun;
920 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
921 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
922
923 std::shared_ptr<DS::VolumeInfo> vol = std::make_shared<DS::VolumeInfo>();
924
925 NVal a = NVal(env, funcArg[NARG_POS::FIRST]).GetProp("vol");
926 if (a.TypeIs(napi_object)) {
927 } else if (a.TypeIs(napi_undefined)) {
928 } else if (a.TypeIs(napi_null)) {
929 }
930
931 VolToDesCription(env, a, vol);
932
933 std::string desCription;
934 bool s = dsm->GetBestVolumeDescription(vol, desCription);
935 if (s) {
936 NVal obj = NVal::CreateObject(env);
937 obj.AddProp("desCription", NVal::CreateUTF8String(env, vol->GetDescription()).val_);
938 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, obj.val_);
939 } else {
940 CallBackError(env, napiFailFun, "GetBestVolumeDescription return value error", ERROR);
941 }
942
943 CallComplete(env, napiCompFun);
944 napi_delete_reference(env, napiSuccFun);
945 napi_delete_reference(env, napiFailFun);
946 napi_delete_reference(env, napiCompFun);
947 return NVal::CreateUndefined(env).val_;
948 }
949
GetWritableVolumes(napi_env env,napi_callback_info info)950 napi_value DeviceSMExporter::GetWritableVolumes(napi_env env, napi_callback_info info)
951 {
952 NFuncArg funcArg(env, info);
953 if (!funcArg.InitArgs(NARG_CNT::ONE)) {
954 UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
955 return nullptr;
956 }
957 bool succ = false;
958 napi_ref napiSuccFun, napiCompFun, napiFailFun;
959 tie(succ, napiSuccFun, napiFailFun, napiCompFun) =
960 CommonFunc::GetCallbackHandles(env, funcArg[NARG_POS::FIRST]);
961
962 std::vector<std::shared_ptr<DS::VolumeInfo>> infos;
963 bool ret = dsm->GetWritableVolumes(infos);
964 if (ret) {
965 napi_value getvolumenapi;
966 napi_create_array(env, &getvolumenapi);
967 ForeachVomInfos(infos, env, getvolumenapi, userId);
968 NVal objc = NVal::CreateObject(env);
969 objc.AddProp("volumeInfos", getvolumenapi);
970 CallBackSuccess(env, napiSuccFun, COMMON_NUM::ONE, objc.val_);
971 } else {
972 CallBackError(env, napiFailFun, "GetWritableVolumes not exist", ERROR);
973 }
974
975 CallComplete(env, napiCompFun);
976 napi_delete_reference(env, napiSuccFun);
977 napi_delete_reference(env, napiFailFun);
978 napi_delete_reference(env, napiCompFun);
979 return NVal::CreateUndefined(env).val_;
980 }
981
Export()982 bool DeviceSMExporter::Export()
983 {
984 return exports_.AddProp({
985 NVal::DeclareNapiFunction("mount", Mount),
986 NVal::DeclareNapiFunction("unMount", UnMount),
987 NVal::DeclareNapiFunction("format", Format),
988 NVal::DeclareNapiFunction("partitionPublic", PartitionPublic),
989 NVal::DeclareNapiFunction("partitionPrivate", PartitionPrivate),
990 NVal::DeclareNapiFunction("getVolumes", GetVolumes),
991 NVal::DeclareNapiFunction("getDisks", GetDisks),
992 NVal::DeclareNapiFunction("setPrimaryStorageUuid", SetPrimaryStorageUuid),
993 NVal::DeclareNapiFunction("findVolumeById", FindVolumeById),
994 NVal::DeclareNapiFunction("findVolumeByUuid", FindVolumeByUuid),
995 NVal::DeclareNapiFunction("findDiskById", FindDiskById),
996 NVal::DeclareNapiFunction("getPrimaryStorageUuid", GetPrimaryStorageUuid),
997 NVal::DeclareNapiFunction("findPrivateForEmulate", FindPrivateForEmulate),
998 NVal::DeclareNapiFunction("findEmulateForPrivate", FindEmulateForPrivate),
999 NVal::DeclareNapiFunction("getWritableVolumes", GetWritableVolumes),
1000 NVal::DeclareNapiFunction("getBestVolumeDescription", GetBestVolumeDescription),
1001 NVal::DeclareNapiFunction("isEncrypted", IsEncrypted),
1002 });
1003 }
1004
GetClassName()1005 string DeviceSMExporter::GetClassName()
1006 {
1007 return DeviceSMExporter::className_;
1008 }
1009
DeviceSMExporter(napi_env env,napi_value exports)1010 DeviceSMExporter::DeviceSMExporter(napi_env env, napi_value exports)
1011 : NExporter(env, exports)
1012 {}
1013
~DeviceSMExporter()1014 DeviceSMExporter::~DeviceSMExporter() {}
1015 } // namespace ModuleDSMExpoter
1016 } // namespace DistributedFS
1017 } // namespace OHOS
1018