1 /*
2  * Copyright (c) 2022-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 "file_access_helper.h"
17 
18 
19 #include <nlohmann/json.hpp>
20 #include "bundle_constants.h"
21 #include "bundle_mgr_proxy.h"
22 #include "file_access_framework_errno.h"
23 #include "file_access_extension_info.h"
24 #include "file_access_service_proxy.h"
25 #include "hilog_wrapper.h"
26 #include "hitrace_meter.h"
27 #include "user_access_tracer.h"
28 #include "if_system_ability_manager.h"
29 #include "ifile_access_ext_base.h"
30 #include "ipc_skeleton.h"
31 #include "iservice_registry.h"
32 #include "system_ability_definition.h"
33 #include "tokenid_kit.h"
34 #include "n_error.h"
35 
36 namespace OHOS {
37 namespace FileAccessFwk {
38 using json = nlohmann::json;
39 namespace {
40     constexpr int COPY_EXCEPTION = -1;
41     constexpr int COPY_NOEXCEPTION = -2;
42 }
43 
44 sptr<IFileAccessExtBase> g_sourceExtProxy;
45 sptr<IFileAccessExtBase> g_destExtProxy;
46 
47 std::vector<Uri> deviceUris(DEVICE_ROOTS.begin(), DEVICE_ROOTS.end());
48 
GetUserId()49 static int GetUserId()
50 {
51     int uid = IPCSkeleton::GetCallingUid();
52     int userId = uid / AppExecFwk::Constants::BASE_USER_RANGE;
53     return userId;
54 }
55 
GetBundleNameFromPath(const std::string & path,std::string & bundleName)56 static bool GetBundleNameFromPath(const std::string &path, std::string &bundleName)
57 {
58     if (path.size() == 0) {
59         HILOG_ERROR("Uri path error.");
60         return false;
61     }
62 
63     if (path.front() != '/') {
64         HILOG_ERROR("Uri path format error.");
65         return false;
66     }
67 
68     auto tmpPath = path.substr(1);
69     auto index = tmpPath.find_first_of("/");
70     bundleName = tmpPath.substr(0, index);
71     if (bundleName.compare(MEDIA_BNUDLE_NAME_ALIAS) == 0) {
72         bundleName = MEDIA_BNUDLE_NAME;
73         return true;
74     }
75     if (bundleName.compare(EXTERNAL_BNUDLE_NAME_ALIAS) == 0) {
76         bundleName = EXTERNAL_BNUDLE_NAME;
77         return true;
78     }
79     HILOG_INFO("Uri-authority true.");
80     return true;
81 }
82 
CheckUri(Uri & uri)83 static bool CheckUri(Uri &uri)
84 {
85     HILOG_DEBUG("Uri : %{private}s.", uri.ToString().c_str());
86     std::string schemeStr = std::string(uri.GetScheme());
87     if (schemeStr.compare(FILE_SCHEME_NAME) != 0) {
88         HILOG_ERROR("Uri scheme error.");
89         return false;
90     }
91     return true;
92 }
93 
GetBundleMgrProxy()94 sptr<AppExecFwk::IBundleMgr> FileAccessHelper::GetBundleMgrProxy()
95 {
96     sptr<ISystemAbilityManager> systemAbilityManager =
97         SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
98     if (!systemAbilityManager) {
99         return nullptr;
100     }
101 
102     sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
103     if (!remoteObject) {
104         return nullptr;
105     }
106 
107     return iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
108 }
109 
FileAccessHelper(const std::shared_ptr<OHOS::AbilityRuntime::Context> & context,const std::unordered_map<std::string,std::shared_ptr<ConnectInfo>> & cMap)110 FileAccessHelper::FileAccessHelper(const std::shared_ptr<OHOS::AbilityRuntime::Context> &context,
111     const std::unordered_map<std::string, std::shared_ptr<ConnectInfo>> &cMap)
112 {
113     if (context != nullptr) {
114         HILOG_INFO("Create FileAccessHelper by context");
115         token_ = context->GetToken();
116         cMap_ = cMap;
117     } else {
118         HILOG_ERROR("Context is null");
119     }
120 }
121 
FileAccessHelper(const sptr<IRemoteObject> & token,const std::unordered_map<std::string,std::shared_ptr<ConnectInfo>> & cMap)122 FileAccessHelper::FileAccessHelper(const sptr<IRemoteObject> &token,
123     const std::unordered_map<std::string, std::shared_ptr<ConnectInfo>> &cMap)
124 {
125     HILOG_INFO("Create FileAccessHelper by token");
126     token_ = token;
127     cMap_ = cMap;
128 }
129 
~FileAccessHelper()130 FileAccessHelper::~FileAccessHelper()
131 {
132     Release();
133 }
134 
GetConnectInfo(const std::string & bundleName)135 std::shared_ptr<ConnectInfo> FileAccessHelper::GetConnectInfo(const std::string &bundleName)
136 {
137     auto iterator = cMap_.find(bundleName);
138     if (iterator != cMap_.end()) {
139         return iterator->second;
140     }
141     HILOG_ERROR("GetConnectInfo called with bundleName return nullptr");
142     return nullptr;
143 }
144 
GetConnectExtensionInfo(Uri & uri)145 std::shared_ptr<ConnectExtensionInfo> FileAccessHelper::GetConnectExtensionInfo(Uri &uri)
146 {
147     std::string scheme = uri.GetScheme();
148     std::string bundleName;
149     if (scheme == FILE_SCHEME_NAME) {
150         std::string path = "/" + uri.GetAuthority() + uri.GetPath();
151         if (!GetBundleNameFromPath(path, bundleName)) {
152             HILOG_ERROR("Get BundleName failed.");
153         }
154     }
155     auto connectInfo = GetConnectInfo(bundleName);
156     if (connectInfo == nullptr) {
157         HILOG_ERROR("Get connectInfo failed.");
158         return nullptr;
159     }
160     std::shared_ptr<ConnectExtensionInfo> connectExtensionInfo =
161         std::make_shared<ConnectExtensionInfo>(connectInfo->want, token_);
162     return connectExtensionInfo;
163 }
164 
IsSystemApp()165 static bool IsSystemApp()
166 {
167     uint64_t accessTokenIDEx = OHOS::IPCSkeleton::GetCallingFullTokenID();
168     return OHOS::Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(accessTokenIDEx);
169 }
170 
CompareWant(const AAFwk::Want & lhs,const AAFwk::Want & rhs)171 bool FileAccessHelper::CompareWant(const AAFwk::Want& lhs, const AAFwk::Want& rhs)
172 {
173     auto lhsElement = lhs.GetElement();
174     auto rhsElement = rhs.GetElement();
175     return lhsElement.GetBundleName() < rhsElement.GetBundleName()
176         && lhsElement.GetAbilityName() < rhsElement.GetAbilityName();
177 }
178 
IsEffectiveWants(const std::vector<AAFwk::Want> & wants)179 bool FileAccessHelper::IsEffectiveWants(const std::vector<AAFwk::Want> &wants)
180 {
181     std::vector<AAFwk::Want> allWants;
182     if (GetRegisteredFileAccessExtAbilityInfo(allWants) != ERR_OK) {
183         HILOG_ERROR("GetRegisteredFileAccessExtAbilityInfo failed");
184         return false;
185     }
186     std::set<AAFwk::Want, bool(*)(const AAFwk::Want&, const AAFwk::Want&)> allWantSet(FileAccessHelper::CompareWant);
187     allWantSet.insert(allWants.begin(), allWants.end());
188     for (auto iter = wants.begin(); iter != wants.end(); ++iter) {
189         if (allWantSet.count(*iter) == 0) {
190             return false;
191         }
192     }
193     return true;
194 }
195 
DoCreatorHelper(const sptr<IRemoteObject> & token,const std::vector<AAFwk::Want> & wants)196 std::pair<std::shared_ptr<FileAccessHelper>, int> FileAccessHelper::DoCreatorHelper(
197     const sptr<IRemoteObject> &token, const std::vector<AAFwk::Want> &wants)
198 {
199     std::unordered_map<std::string, std::shared_ptr<ConnectInfo>> cMap;
200     for (size_t i = 0; i < wants.size(); i++) {
201         sptr<AppFileAccessExtConnection> fileAccessExtConnection(new(std::nothrow) AppFileAccessExtConnection());
202         if (fileAccessExtConnection == nullptr) {
203             HILOG_ERROR("new fileAccessExtConnection fail");
204             return {nullptr, E_GETRESULT};
205         }
206         if (!fileAccessExtConnection->IsExtAbilityConnected()) {
207             fileAccessExtConnection->ConnectFileExtAbility(wants[i]);
208         }
209         sptr<IFileAccessExtBase> fileExtProxy = fileAccessExtConnection->GetFileExtProxy();
210         if (fileExtProxy == nullptr) {
211             HILOG_ERROR("Creator get invalid fileExtProxy");
212             return {nullptr, E_CONNECT};
213         }
214         std::shared_ptr<ConnectInfo> connectInfo = std::make_shared<ConnectInfo>();
215         if (!connectInfo) {
216             HILOG_ERROR("Creator, connectInfo == nullptr");
217             return {nullptr, E_GETRESULT};
218         }
219         connectInfo->want = wants[i];
220         connectInfo->fileAccessExtConnection = fileAccessExtConnection;
221         std::string bundleName = wants[i].GetElement().GetBundleName();
222         cMap.insert(std::pair<std::string, std::shared_ptr<ConnectInfo>>(bundleName, connectInfo));
223     }
224 
225     FileAccessHelper *ptrFileAccessHelper = new (std::nothrow) FileAccessHelper(token, cMap);
226     if (ptrFileAccessHelper == nullptr) {
227         HILOG_ERROR("Creator failed, create FileAccessHelper failed");
228         return {nullptr, E_GETRESULT};
229     }
230 
231     return {std::shared_ptr<FileAccessHelper>(ptrFileAccessHelper), ERR_OK};
232 }
233 
Creator(const std::shared_ptr<OHOS::AbilityRuntime::Context> & context)234 std::pair<std::shared_ptr<FileAccessHelper>, int> FileAccessHelper::Creator(
235     const std::shared_ptr<OHOS::AbilityRuntime::Context> &context)
236 {
237     UserAccessTracer trace;
238     trace.Start("Creator");
239     std::vector<AAFwk::Want> allWants;
240     if (context == nullptr) {
241         HILOG_ERROR("FileAccessHelper::Creator failed, context == nullptr");
242         return {nullptr, EINVAL};
243     }
244     if (!IsSystemApp()) {
245         HILOG_ERROR("FileAccessHelper::Creator check IsSystemAppByFullTokenID failed");
246         return {nullptr, E_PERMISSION_SYS};
247     }
248     if (GetRegisteredFileAccessExtAbilityInfo(allWants) != ERR_OK) {
249         HILOG_ERROR("GetRegisteredFileAccessExtAbilityInfo failed");
250         return {nullptr, E_GETINFO};
251     }
252 
253     return DoCreatorHelper(context->GetToken(), allWants);
254 }
255 
Creator(const std::shared_ptr<OHOS::AbilityRuntime::Context> & context,const std::vector<AAFwk::Want> & wants)256 std::pair<std::shared_ptr<FileAccessHelper>, int> FileAccessHelper::Creator(
257     const std::shared_ptr<OHOS::AbilityRuntime::Context> &context, const std::vector<AAFwk::Want> &wants)
258 {
259     UserAccessTracer trace;
260     trace.Start("Creator");
261     if (context == nullptr) {
262         HILOG_ERROR("FileAccessHelper::Creator failed, context == nullptr");
263         return {nullptr, EINVAL};
264     }
265     if (wants.size() == 0) {
266         HILOG_ERROR("FileAccessHelper::Creator failed, wants is empty");
267         return {nullptr, EINVAL};
268     }
269     if (!IsSystemApp()) {
270         HILOG_ERROR("FileAccessHelper::Creator check IsSystemAppByFullTokenID failed");
271         return {nullptr, E_PERMISSION_SYS};
272     }
273     // 传入的wants信息是否有效
274     if (!IsEffectiveWants(wants)) {
275         HILOG_ERROR("FileAccessHelper::Creator effectiveWants is empty");
276         return {nullptr, EINVAL};
277     }
278 
279     return DoCreatorHelper(context->GetToken(), wants);
280 }
281 
Creator(const sptr<IRemoteObject> & token,const std::vector<AAFwk::Want> & wants)282 std::shared_ptr<FileAccessHelper> FileAccessHelper::Creator(const sptr<IRemoteObject> &token,
283     const std::vector<AAFwk::Want> &wants)
284 {
285     UserAccessTracer trace;
286     trace.Start("Creator");
287     if (token == nullptr) {
288         HILOG_ERROR("FileAccessHelper::Creator failed, token == nullptr");
289         return nullptr;
290     }
291     if (wants.size() == 0) {
292         HILOG_ERROR("FileAccessHelper::Creator failed, wants is empty");
293         return nullptr;
294     }
295     if (!IsSystemApp()) {
296         HILOG_ERROR("FileAccessHelper::Creator check IsSystemAppByFullTokenID failed");
297         return nullptr;
298     }
299     // 传入的wants信息是否有效
300     if (!IsEffectiveWants(wants)) {
301         HILOG_ERROR("FileAccessHelper::Creator wants is not effective");
302         return nullptr;
303     }
304 
305     std::pair<std::shared_ptr<FileAccessHelper>, int> ptrFileAccessHelper = DoCreatorHelper(token, wants);
306     if (ptrFileAccessHelper.second != ERR_OK) {
307         return nullptr;
308     }
309 
310     return ptrFileAccessHelper.first;
311 }
312 
Release()313 bool FileAccessHelper::Release()
314 {
315     for (auto iter = cMap_.begin(); iter != cMap_.end(); iter++) {
316         if (iter->second->fileAccessExtConnection->IsExtAbilityConnected()) {
317             iter->second->fileAccessExtConnection->DisconnectFileExtAbility();
318         }
319     }
320     cMap_.clear();
321     token_ = nullptr;
322     return true;
323 }
324 
GetProxyByUri(Uri & uri)325 sptr<IFileAccessExtBase> FileAccessHelper::GetProxyByUri(Uri &uri)
326 {
327     std::string scheme = uri.GetScheme();
328     std::string bundleName;
329     if (scheme == FILE_SCHEME_NAME) {
330         std::string path = "/" + uri.GetAuthority() + uri.GetPath();
331         if (!GetBundleNameFromPath(path, bundleName)) {
332             HILOG_ERROR("Get BundleName failed.");
333             return nullptr;
334         }
335     }
336 
337     auto fileAccessExtProxy = GetProxyByBundleName(bundleName);
338     return fileAccessExtProxy;
339 }
340 
GetProxyByBundleName(const std::string & bundleName)341 sptr<IFileAccessExtBase> FileAccessHelper::GetProxyByBundleName(const std::string &bundleName)
342 {
343     auto connectInfo = GetConnectInfo(bundleName);
344     if (connectInfo == nullptr) {
345         HILOG_ERROR("GetProxyByUri failed with invalid connectInfo");
346         return nullptr;
347     }
348     if (!connectInfo->fileAccessExtConnection->IsExtAbilityConnected()) {
349         connectInfo->fileAccessExtConnection->ConnectFileExtAbility(connectInfo->want);
350     }
351     auto fileAccessExtProxy = connectInfo->fileAccessExtConnection->GetFileExtProxy();
352     if (fileAccessExtProxy == nullptr) {
353         HILOG_ERROR("GetProxyByUri failed with invalid fileAccessExtProxy");
354         return nullptr;
355     }
356     return fileAccessExtProxy;
357 }
358 
GetProxy()359 bool FileAccessHelper::GetProxy()
360 {
361     for (auto iter = cMap_.begin(); iter != cMap_.end(); ++iter) {
362         auto connectInfo = iter->second;
363         if (!connectInfo->fileAccessExtConnection->IsExtAbilityConnected()) {
364             connectInfo->fileAccessExtConnection->ConnectFileExtAbility(connectInfo->want);
365         }
366         auto fileAccessExtProxy = connectInfo->fileAccessExtConnection->GetFileExtProxy();
367         if (fileAccessExtProxy == nullptr) {
368             HILOG_ERROR("GetProxy failed with invalid fileAccessExtProxy");
369             return false;
370         }
371     }
372     return true;
373 }
374 
OpenFile(Uri & uri,int flags,int & fd)375 int FileAccessHelper::OpenFile(Uri &uri, int flags, int &fd)
376 {
377     UserAccessTracer trace;
378     trace.Start("OpenFile");
379     if (!IsSystemApp()) {
380         HILOG_ERROR("FileAccessHelper::OpenFile check IsSystemAppByFullTokenID failed");
381         return E_PERMISSION_SYS;
382     }
383 
384     if (!CheckUri(uri)) {
385         HILOG_ERROR("Uri format check error.");
386         return E_URIS;
387     }
388 
389     if (flags != READ && flags != WRITE && flags != WRITE_READ) {
390         HILOG_ERROR("flags type error.");
391         return EINVAL;
392     }
393 
394     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(uri);
395     if (fileExtProxy == nullptr) {
396         HILOG_ERROR("failed with invalid fileAccessExtProxy");
397         return E_IPCS;
398     }
399 
400     int ret = fileExtProxy->OpenFile(uri, flags, fd);
401     if (ret != ERR_OK) {
402         HILOG_ERROR("OpenFile get result error, code:%{public}d", ret);
403         return ret;
404     }
405 
406     return ERR_OK;
407 }
408 
CreateFile(Uri & parent,const std::string & displayName,Uri & newFile)409 int FileAccessHelper::CreateFile(Uri &parent, const std::string &displayName, Uri &newFile)
410 {
411     UserAccessTracer trace;
412     trace.Start("CreateFile");
413     if (!IsSystemApp()) {
414         HILOG_ERROR("FileAccessHelper::CreateFile check IsSystemAppByFullTokenID failed");
415         return E_PERMISSION_SYS;
416     }
417 
418     if (!CheckUri(parent)) {
419         HILOG_ERROR("Uri format check error.");
420         return E_URIS;
421     }
422 
423     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(parent);
424     if (fileExtProxy == nullptr) {
425         HILOG_ERROR("failed with invalid fileAccessExtProxy");
426         return E_IPCS;
427     }
428 
429     int ret = fileExtProxy->CreateFile(parent, displayName, newFile);
430     if (ret != ERR_OK) {
431         HILOG_ERROR("CreateFile get result error, code:%{public}d", ret);
432         return ret;
433     }
434 
435     return ERR_OK;
436 }
437 
Mkdir(Uri & parent,const std::string & displayName,Uri & newDir)438 int FileAccessHelper::Mkdir(Uri &parent, const std::string &displayName, Uri &newDir)
439 {
440     UserAccessTracer trace;
441     trace.Start("Mkdir");
442     if (!IsSystemApp()) {
443         HILOG_ERROR("FileAccessHelper::Mkdir check IsSystemAppByFullTokenID failed");
444         return E_PERMISSION_SYS;
445     }
446 
447     if (!CheckUri(parent)) {
448         HILOG_ERROR("Uri format check error.");
449         return E_URIS;
450     }
451 
452     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(parent);
453     if (fileExtProxy == nullptr) {
454         HILOG_ERROR("failed with invalid fileAccessExtProxy");
455         return E_IPCS;
456     }
457 
458     int ret = fileExtProxy->Mkdir(parent, displayName, newDir);
459     if (ret != ERR_OK) {
460         HILOG_ERROR("Mkdir get result error, code:%{public}d", ret);
461         return ret;
462     }
463 
464     return ERR_OK;
465 }
466 
Delete(Uri & selectFile)467 int FileAccessHelper::Delete(Uri &selectFile)
468 {
469     UserAccessTracer trace;
470     trace.Start("Delete");
471     if (!IsSystemApp()) {
472         HILOG_ERROR("FileAccessHelper::Delete check IsSystemAppByFullTokenID failed");
473         return E_PERMISSION_SYS;
474     }
475 
476     if (!CheckUri(selectFile)) {
477         HILOG_ERROR("Uri format check error.");
478         return E_URIS;
479     }
480 
481     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(selectFile);
482     if (fileExtProxy == nullptr) {
483         HILOG_ERROR("failed with invalid fileAccessExtProxy");
484         return E_IPCS;
485     }
486 
487     int ret = fileExtProxy->Delete(selectFile);
488     if (ret != ERR_OK) {
489         HILOG_ERROR("Delete get result error, code:%{public}d", ret);
490         return ret;
491     }
492 
493     return ERR_OK;
494 }
495 
Move(Uri & sourceFile,Uri & targetParent,Uri & newFile)496 int FileAccessHelper::Move(Uri &sourceFile, Uri &targetParent, Uri &newFile)
497 {
498     UserAccessTracer trace;
499     trace.Start("Move");
500     if (!IsSystemApp()) {
501         HILOG_ERROR("FileAccessHelper::Move check IsSystemAppByFullTokenID failed");
502         return E_PERMISSION_SYS;
503     }
504 
505     Uri sourceFileUri(sourceFile.ToString());
506     Uri targetParentUri(targetParent.ToString());
507     if (!CheckUri(sourceFile) || !CheckUri(targetParent)) {
508         HILOG_ERROR("uri format check error.");
509         return E_URIS;
510     }
511 
512     if (sourceFileUri.GetAuthority() != targetParentUri.GetAuthority()) {
513         HILOG_WARN("Operation failed, move not supported");
514         return EPERM;
515     }
516 
517     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
518     if (fileExtProxy == nullptr) {
519         HILOG_ERROR("failed with invalid fileAccessExtProxy");
520         return E_IPCS;
521     }
522 
523     int ret = fileExtProxy->Move(sourceFile, targetParent, newFile);
524     if (ret != ERR_OK) {
525         HILOG_ERROR("Move get result error, code:%{public}d", ret);
526         return ret;
527     }
528 
529     return ERR_OK;
530 }
531 
IsDirectory(Uri & uri,bool & isDir)532 int FileAccessHelper::IsDirectory(Uri &uri, bool &isDir)
533 {
534     sptr<IFileAccessExtBase> proxy = FileAccessHelper::GetProxyByUri(uri);
535     if (proxy == nullptr) {
536         HILOG_ERROR("failed with invalid fileAccessExtProxy");
537         return E_IPCS;
538     }
539 
540     FileInfo fileInfo;
541     int ret = proxy->GetFileInfoFromUri(uri, fileInfo);
542     if (ret != ERR_OK) {
543         HILOG_ERROR("get FileInfo from uri error, code:%{public}d", ret);
544         return ret;
545     }
546 
547     isDir = fileInfo.mode >= 0 && (static_cast<uint32_t>(fileInfo.mode) & DOCUMENT_FLAG_REPRESENTS_DIR) != 0;
548 
549     return ret;
550 }
551 
TranslateResult(int errCode,Result & result)552 static int TranslateResult(int errCode, Result &result)
553 {
554     if (errCode == COPY_EXCEPTION || errCode == ERR_OK) {
555         return errCode;
556     }
557 
558     int ret = ERR_OK;
559     switch (errCode) {
560         case E_IPCS:
561         case E_URIS:
562         case ERR_NOMEM:
563         case E_PERMISSION_SYS:
564         case ERR_PERM: {
565             HILOG_ERROR("Operate exception, terminate");
566             ret = COPY_EXCEPTION;
567             break;
568         }
569         default: {
570             HILOG_ERROR("Operate exception, continue");
571             ret = COPY_NOEXCEPTION;
572             break;
573         }
574     }
575     if (OHOS::FileManagement::LibN::errCodeTable.find(errCode) !=
576         OHOS::FileManagement::LibN::errCodeTable.end()) {
577         result.errCode = OHOS::FileManagement::LibN::errCodeTable.at(errCode).first;
578         result.errMsg = OHOS::FileManagement::LibN::errCodeTable.at(errCode).second;
579     }
580     return ret;
581 }
582 
GetResult(const std::string & sourceUri,const std::string & destUri,int errCode,const std::string & errMsg,std::vector<Result> & result)583 static int GetResult(const std::string &sourceUri, const std::string &destUri, int errCode,
584     const std::string &errMsg, std::vector<Result> &result)
585 {
586     Result tmpResult { sourceUri, destUri, errCode, errMsg };
587     int ret = TranslateResult(errCode, tmpResult);
588     result.clear();
589     result.push_back(tmpResult);
590     return ret;
591 }
592 
CopyOperation(Uri & sourceUri,Uri & destUri,std::vector<Result> & copyResult,bool force)593 int FileAccessHelper::CopyOperation(Uri &sourceUri, Uri &destUri, std::vector<Result> &copyResult, bool force)
594 {
595     UserAccessTracer trace;
596     trace.Start("CopyOperation");
597     int ret = COPY_EXCEPTION;
598     sptr<IFileAccessExtBase> proxy = GetProxyByUri(sourceUri);
599     if (proxy == nullptr) {
600         HILOG_ERROR("Failed with invalid fileAccessExtProxy");
601         Result result;
602         ret = TranslateResult(E_IPCS, result);
603         copyResult.push_back(result);
604         return ret;
605     }
606 
607     ret = proxy->Copy(sourceUri, destUri, copyResult, force);
608     if (ret != ERR_OK) {
609         if ((ret == COPY_EXCEPTION) || (ret == COPY_NOEXCEPTION)) {
610             HILOG_ERROR("Copy exception, code:%{public}d", ret);
611             return ret;
612         }
613         HILOG_ERROR("Copy error, code:%{public}d", ret);
614         Result result { "", "", ret, "" };
615         ret = TranslateResult(ret, result);
616         copyResult.push_back(result);
617         return ret;
618     }
619     return ret;
620 }
621 
CopyFileOperation(Uri & sourceUri,Uri & destUri,const std::string & fileName,Uri & newFileUri)622 int FileAccessHelper::CopyFileOperation(Uri &sourceUri, Uri &destUri, const std::string &fileName, Uri &newFileUri)
623 {
624     UserAccessTracer trace;
625     trace.Start("CopyFileOperation");
626     sptr<IFileAccessExtBase> proxy = GetProxyByUri(sourceUri);
627     if (proxy == nullptr) {
628         HILOG_ERROR("Failed with invalid fileAccessExtProxy");
629         return E_IPCS;
630     }
631 
632     int ret = proxy->CopyFile(sourceUri, destUri, fileName, newFileUri);
633     if (ret != ERR_OK) {
634         HILOG_ERROR("Copy file error, code:%{public}d", ret);
635         return ret;
636     }
637     return ret;
638 }
639 
Copy(Uri & sourceUri,Uri & destUri,std::vector<Result> & copyResult,bool force)640 int FileAccessHelper::Copy(Uri &sourceUri, Uri &destUri, std::vector<Result> &copyResult, bool force)
641 {
642     UserAccessTracer trace;
643     trace.Start("Copy");
644     if (!IsSystemApp()) {
645         HILOG_ERROR("Copy check IsSystemAppByFullTokenID failed");
646         return GetResult("", "", E_PERMISSION_SYS, "", copyResult);
647     }
648 
649     if (!CheckUri(sourceUri) || !CheckUri(destUri)) {
650         HILOG_ERROR("Uri format check error");
651         return GetResult("", "", E_URIS, "", copyResult);
652     }
653 
654     bool isDir = false;
655     int ret = IsDirectory(destUri, isDir);
656     if (ret != ERR_OK) {
657         HILOG_ERROR("Get uri type error");
658         GetResult("", "", ret, "", copyResult);
659         return COPY_EXCEPTION;
660     }
661     if (!isDir) {
662         HILOG_ERROR("Destination uri is not directory");
663         return GetResult("", "", E_URIS, "", copyResult);
664     }
665 
666     ret = CopyOperation(sourceUri, destUri, copyResult, force);
667     return ret;
668 }
669 
CopyFile(Uri & sourceUri,Uri & destUri,const std::string & fileName,Uri & newFileUri)670 int FileAccessHelper::CopyFile(Uri &sourceUri, Uri &destUri, const std::string &fileName, Uri &newFileUri)
671 {
672     UserAccessTracer trace;
673     trace.Start("CopyFile");
674     if (!IsSystemApp()) {
675         HILOG_ERROR("Copy check IsSystemAppByFullTokenID failed");
676         return E_PERMISSION_SYS;
677     }
678 
679     if (!CheckUri(sourceUri) || !CheckUri(destUri)) {
680         HILOG_ERROR("Uri format check error");
681         return E_URIS;
682     }
683 
684     bool isDir = false;
685     int ret = IsDirectory(destUri, isDir);
686     if (ret != ERR_OK) {
687         HILOG_ERROR("Get uri type error");
688         return E_GETRESULT;
689     }
690     if (!isDir) {
691         HILOG_ERROR("Destination uri is not directory");
692         return E_URIS;
693     }
694     ret = CopyFileOperation(sourceUri, destUri, fileName, newFileUri);
695     return ret;
696 }
697 
Rename(Uri & sourceFile,const std::string & displayName,Uri & newFile)698 int FileAccessHelper::Rename(Uri &sourceFile, const std::string &displayName, Uri &newFile)
699 {
700     UserAccessTracer trace;
701     trace.Start("Rename");
702     if (!IsSystemApp()) {
703         HILOG_ERROR("FileAccessHelper::Rename check IsSystemAppByFullTokenID failed");
704         return E_PERMISSION_SYS;
705     }
706 
707     if (!CheckUri(sourceFile)) {
708         HILOG_ERROR("sourceFile format check error.");
709         return E_URIS;
710     }
711 
712     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
713     if (fileExtProxy == nullptr) {
714         HILOG_ERROR("failed with invalid fileAccessExtProxy");
715         return E_IPCS;
716     }
717 
718     int ret = fileExtProxy->Rename(sourceFile, displayName, newFile);
719     if (ret != ERR_OK) {
720         HILOG_ERROR("Rename get result error, code:%{public}d", ret);
721         return ret;
722     }
723 
724     return ERR_OK;
725 }
726 
ListFile(const FileInfo & fileInfo,const int64_t offset,const FileFilter & filter,SharedMemoryInfo & memInfo)727 int FileAccessHelper::ListFile(const FileInfo &fileInfo, const int64_t offset, const FileFilter &filter,
728     SharedMemoryInfo &memInfo)
729 {
730     UserAccessTracer trace;
731     trace.Start("ListFile");
732     if (!IsSystemApp()) {
733         HILOG_ERROR("FileAccessHelper::ListFile check IsSystemAppByFullTokenID failed");
734         return E_PERMISSION_SYS;
735     }
736 
737     Uri sourceFile(fileInfo.uri);
738     if (!CheckUri(sourceFile)) {
739         HILOG_ERROR("sourceFile format check error.");
740         return E_URIS;
741     }
742 
743     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
744     if (fileExtProxy == nullptr) {
745         HILOG_ERROR("failed with invalid fileAccessExtProxy");
746         return E_IPCS;
747     }
748 
749     memInfo.Clear();
750     int ret = fileExtProxy->ListFile(fileInfo, offset, filter, memInfo);
751     if (ret != ERR_OK) {
752         HILOG_ERROR("ListFile get result error, code:%{public}d", ret);
753         return ret;
754     }
755     return ERR_OK;
756 }
757 
ScanFile(const FileInfo & fileInfo,const int64_t offset,const int64_t maxCount,const FileFilter & filter,std::vector<FileInfo> & fileInfoVec)758 int FileAccessHelper::ScanFile(const FileInfo &fileInfo, const int64_t offset, const int64_t maxCount,
759     const FileFilter &filter, std::vector<FileInfo> &fileInfoVec)
760 {
761     UserAccessTracer trace;
762     trace.Start("ScanFile");
763     if (!IsSystemApp()) {
764         HILOG_ERROR("FileAccessHelper::ScanFile check IsSystemAppByFullTokenID failed");
765         return E_PERMISSION_SYS;
766     }
767 
768     Uri sourceFile(fileInfo.uri);
769     if (!CheckUri(sourceFile)) {
770         HILOG_ERROR("sourceFile format check error.");
771         return E_URIS;
772     }
773 
774     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
775     if (fileExtProxy == nullptr) {
776         HILOG_ERROR("failed with invalid fileAccessExtProxy");
777         return E_IPCS;
778     }
779 
780     int ret = fileExtProxy->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
781     if (ret != ERR_OK) {
782         HILOG_ERROR("ScanFile get result error, code:%{public}d", ret);
783         return ret;
784     }
785 
786     return ERR_OK;
787 }
788 
GetQueryColumns(std::string & uri,std::string & metaJson,std::vector<std::string> & columns)789 static int GetQueryColumns(std::string &uri, std::string &metaJson, std::vector<std::string> &columns)
790 {
791     if (!json::accept(metaJson)) {
792         HILOG_ERROR("metaJson format check error.");
793         return EINVAL;
794     }
795 
796     auto jsonObject = json::parse(metaJson);
797     for (json::iterator it = jsonObject.begin(); it != jsonObject.end(); ++it) {
798         auto iterator = FILE_RESULT_TYPE.find(it.key());
799         if (iterator == FILE_RESULT_TYPE.end()) {
800             HILOG_ERROR("columns format check error.");
801             return EINVAL;
802         }
803         columns.push_back(it.key());
804     }
805 
806     if (columns.empty()) {
807         HILOG_ERROR("columns is empty.");
808         return EINVAL;
809     }
810     return ERR_OK;
811 }
812 
GetQueryResult(std::string & uri,std::vector<std::string> & columns,std::vector<std::string> & results,std::string & metaJson)813 static int GetQueryResult(std::string &uri, std::vector<std::string> &columns, std::vector<std::string> &results,
814     std::string &metaJson)
815 {
816     json jsonObject;
817     for (size_t i = 0; i < columns.size(); i++) {
818         auto memberType = FILE_RESULT_TYPE.at(columns.at(i));
819         // Assign a default value based on the type, When fileIo obtains an invalid value.
820         switch (memberType) {
821             case STRING_TYPE:
822                 if (results[i].empty()) {
823                     results[i] = " ";
824                 }
825                 jsonObject[columns[i]] = results[i];
826                 break;
827             case INT32_TYPE:
828                 if (results[i].empty()) {
829                     results[i] = "0";
830                 }
831                 jsonObject[columns[i]] = std::stoi(results[i]);
832                 break;
833             case INT64_TYPE:
834                 if (results[i].empty()) {
835                     results[i] = "0";
836                 }
837                 jsonObject[columns[i]] = std::stol(results[i]);
838                 break;
839             default:
840                 jsonObject[columns[i]] = " ";
841                 HILOG_ERROR("not match  memberType %{public}d", memberType);
842                 break;
843         }
844     }
845     metaJson = jsonObject.dump();
846     return ERR_OK;
847 }
848 
Query(Uri & uri,std::string & metaJson)849 int FileAccessHelper::Query(Uri &uri, std::string &metaJson)
850 {
851     UserAccessTracer trace;
852     trace.Start("Query");
853     if (!IsSystemApp()) {
854         HILOG_ERROR("FileAccessHelper::Query check IsSystemAppByFullTokenID failed");
855         return E_PERMISSION_SYS;
856     }
857 
858     if (!CheckUri(uri)) {
859         HILOG_ERROR("Uri format check error.");
860         return E_URIS;
861     }
862 
863     std::string uriString(uri.ToString());
864     std::vector<std::string> columns;
865     std::vector<std::string> results;
866     int ret = GetQueryColumns(uriString, metaJson, columns);
867     if (ret != ERR_OK) {
868         HILOG_ERROR("Query get columns error, code:%{public}d", ret);
869         return ret;
870     }
871 
872     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(uri);
873     if (fileExtProxy == nullptr) {
874         HILOG_ERROR("failed with invalid fileAccessExtProxy");
875         return E_IPCS;
876     }
877 
878     ret = fileExtProxy->Query(uri, columns, results);
879     if (ret != ERR_OK) {
880         HILOG_ERROR("Query get result error, code:%{public}d", ret);
881         return ret;
882     }
883 
884     ret = GetQueryResult(uriString, columns, results, metaJson);
885     if (ret != ERR_OK) {
886         HILOG_ERROR("Query get result error, code:%{public}d", ret);
887         return ret;
888     }
889 
890     return ERR_OK;
891 }
892 
GetRoots(std::vector<RootInfo> & rootInfoVec)893 int FileAccessHelper::GetRoots(std::vector<RootInfo> &rootInfoVec)
894 {
895     UserAccessTracer trace;
896     trace.Start("GetRoots");
897     if (!IsSystemApp()) {
898         HILOG_ERROR("FileAccessHelper::GetRoots check IsSystemAppByFullTokenID failed");
899         return E_PERMISSION_SYS;
900     }
901 
902     if (!GetProxy()) {
903         HILOG_ERROR("failed with invalid fileAccessExtProxy");
904         return E_IPCS;
905     }
906 
907     int ret = ERR_OK;
908     for (auto iter = cMap_.begin(); iter != cMap_.end(); ++iter) {
909         auto connectInfo = iter->second;
910         auto fileAccessExtProxy = connectInfo->fileAccessExtConnection->GetFileExtProxy();
911         std::vector<RootInfo> results;
912         if (!fileAccessExtProxy) {
913             HILOG_ERROR("GetFileExtProxy return nullptr, bundle name is %{public}s", iter->first.c_str());
914             continue;
915         }
916 
917         ret = fileAccessExtProxy->GetRoots(results);
918         if (ret != ERR_OK) {
919             HILOG_ERROR("getRoots get fail ret:%{public}d", ret);
920             return ret;
921         }
922 
923         rootInfoVec.insert(rootInfoVec.end(), results.begin(), results.end());
924     }
925 
926     return ERR_OK;
927 }
928 
GetRegisteredFileAccessExtAbilityInfo(std::vector<AAFwk::Want> & wantVec)929 int FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo(std::vector<AAFwk::Want> &wantVec)
930 {
931     UserAccessTracer trace;
932     trace.Start("GetRegisteredFileAccessExtAbilityInfo");
933     if (!IsSystemApp()) {
934         HILOG_ERROR("FileAccessHelper::GetRoots check IsSystemAppByFullTokenID failed");
935         return E_PERMISSION_SYS;
936     }
937 
938     std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
939     sptr<AppExecFwk::IBundleMgr> bm = FileAccessHelper::GetBundleMgrProxy();
940     if (bm == nullptr) {
941         HILOG_ERROR("GetBundleMgrProxy nullptr.");
942         return E_GETINFO;
943     }
944     bool ret = bm->QueryExtensionAbilityInfos(
945         AppExecFwk::ExtensionAbilityType::FILEACCESS_EXTENSION, GetUserId(), extensionInfos);
946     if (!ret) {
947         HILOG_ERROR("FileAccessHelper::GetRegisteredFileAccessExtAbilityInfo QueryExtensionAbilityInfos error");
948         return E_GETINFO;
949     }
950 
951     wantVec.clear();
952     for (size_t i = 0; i < extensionInfos.size(); i++) {
953         if (extensionInfos[i].bundleName.empty()) {
954             HILOG_ERROR("GetRegisteredFileAccessExtAbilityInfo extensionInfos.bundleName empty");
955             return E_GETINFO;
956         }
957         AAFwk::Want want;
958         want.SetElementName(extensionInfos[i].bundleName, extensionInfos[i].name);
959         wantVec.push_back(want);
960     }
961 
962     return ERR_OK;
963 }
964 
Access(Uri & uri,bool & isExist)965 int FileAccessHelper::Access(Uri &uri, bool &isExist)
966 {
967     UserAccessTracer trace;
968     trace.Start("Access");
969     if (!IsSystemApp()) {
970         HILOG_ERROR("FileAccessHelper::Access check IsSystemAppByFullTokenID failed");
971         return E_PERMISSION_SYS;
972     }
973 
974     if (!CheckUri(uri)) {
975         HILOG_ERROR("uri format check error.");
976         return E_URIS;
977     }
978 
979     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(uri);
980     if (fileExtProxy == nullptr) {
981         HILOG_ERROR("failed with invalid fileAccessExtProxy");
982         return E_IPCS;
983     }
984 
985     int ret = fileExtProxy->Access(uri, isExist);
986     if (ret != ERR_OK) {
987         HILOG_ERROR("Access get result error, code:%{public}d", ret);
988         return ret;
989     }
990 
991     return ERR_OK;
992 }
993 
GetFileInfoFromUri(Uri & selectFile,FileInfo & fileInfo)994 int FileAccessHelper::GetFileInfoFromUri(Uri &selectFile, FileInfo &fileInfo)
995 {
996     UserAccessTracer trace;
997     trace.Start("GetFileInfoFromUri");
998     if (!IsSystemApp()) {
999         HILOG_ERROR("FileAccessHelper::GetFileInfoFromUri check IsSystemAppByFullTokenID failed");
1000         return E_PERMISSION_SYS;
1001     }
1002 
1003     if (!CheckUri(selectFile)) {
1004         HILOG_ERROR("selectFile uri format check error.");
1005         return E_URIS;
1006     }
1007 
1008     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(selectFile);
1009     if (fileExtProxy == nullptr) {
1010         HILOG_ERROR("failed with invalid fileAccessExtProxy");
1011         return E_IPCS;
1012     }
1013 
1014     int ret = fileExtProxy->GetFileInfoFromUri(selectFile, fileInfo);
1015     if (ret != ERR_OK) {
1016         HILOG_ERROR("GetFileInfoFromUri get result error, code:%{public}d", ret);
1017         return ret;
1018     }
1019 
1020     return ERR_OK;
1021 }
1022 
GetFileInfoFromRelativePath(std::string & selectFile,FileInfo & fileInfo)1023 int FileAccessHelper::GetFileInfoFromRelativePath(std::string &selectFile, FileInfo &fileInfo)
1024 {
1025     UserAccessTracer trace;
1026     trace.Start("GetFileInfoFromRelativePath");
1027     if (!IsSystemApp()) {
1028         HILOG_ERROR("FileAccessHelper::GetFileInfoFromRelativePath check IsSystemAppByFullTokenID failed");
1029         return E_PERMISSION_SYS;
1030     }
1031 
1032     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByBundleName(EXTERNAL_BNUDLE_NAME);
1033     if (fileExtProxy == nullptr) {
1034         HILOG_ERROR("failed with invalid fileAccessExtProxy");
1035         return E_IPCS;
1036     }
1037 
1038     int ret = fileExtProxy->GetFileInfoFromRelativePath(selectFile, fileInfo);
1039     if (ret != ERR_OK) {
1040         HILOG_ERROR("GetFileInfoFromRelativePath get result error, code:%{public}d", ret);
1041         return ret;
1042     }
1043 
1044     return ERR_OK;
1045 }
1046 
RegisterNotify(Uri uri,bool notifyForDescendants,sptr<IFileAccessObserver> & observer)1047 int FileAccessHelper::RegisterNotify(Uri uri, bool notifyForDescendants, sptr<IFileAccessObserver> &observer)
1048 {
1049     UserAccessTracer trace;
1050     trace.Start("RegisterNotify");
1051     if (!IsSystemApp()) {
1052         HILOG_ERROR("FileAccessHelper::RegisterNotify check IsSystemAppByFullTokenID failed");
1053         return E_PERMISSION_SYS;
1054     }
1055 
1056     if (!CheckUri(uri) || observer == nullptr) {
1057         HILOG_ERROR("parameter check error.");
1058         return EINVAL;
1059     }
1060 
1061     auto proxy = FileAccessServiceProxy::GetInstance();
1062     if (proxy == nullptr) {
1063         HILOG_ERROR("RegisterNotify get SA failed");
1064         return E_LOAD_SA;
1065     }
1066 
1067     int ret = proxy->RegisterNotify(uri, notifyForDescendants, observer, GetConnectExtensionInfo(uri));
1068     return ret;
1069 }
1070 
UnregisterNotify(Uri uri,sptr<IFileAccessObserver> & observer)1071 int FileAccessHelper::UnregisterNotify(Uri uri, sptr<IFileAccessObserver> &observer)
1072 {
1073     UserAccessTracer trace;
1074     trace.Start("UnregisterNotify");
1075     if (!IsSystemApp()) {
1076         HILOG_ERROR("FileAccessHelper::UnregisterNotify check IsSystemAppByFullTokenID failed");
1077         return E_PERMISSION_SYS;
1078     }
1079 
1080     if (!CheckUri(uri) || observer == nullptr) {
1081         HILOG_ERROR("parameter check error.");
1082         return EINVAL;
1083     }
1084 
1085     auto proxy = FileAccessServiceProxy::GetInstance();
1086     if (proxy == nullptr) {
1087         HILOG_ERROR("UnregisterNotify get SA failed");
1088         return E_LOAD_SA;
1089     }
1090 
1091     int ret = proxy->UnregisterNotify(uri, observer, GetConnectExtensionInfo(uri));
1092     return ret;
1093 }
1094 
UnregisterNotify(Uri uri)1095 int FileAccessHelper::UnregisterNotify(Uri uri)
1096 {
1097     UserAccessTracer trace;
1098     trace.Start("UnregisterNotify");
1099     if (!IsSystemApp()) {
1100         HILOG_ERROR("FileAccessHelper::UnregisterNotify check IsSystemAppByFullTokenID failed");
1101         return E_PERMISSION_SYS;
1102     }
1103 
1104     if (!CheckUri(uri)) {
1105         HILOG_ERROR("parameter check error.");
1106         return EINVAL;
1107     }
1108     auto proxy = FileAccessServiceProxy::GetInstance();
1109     if (proxy == nullptr) {
1110         HILOG_ERROR("UnregisterNotify get SA failed");
1111         return E_LOAD_SA;
1112     }
1113 
1114     sptr<IFileAccessObserver> observer = nullptr;
1115     int ret = proxy->UnregisterNotify(uri, observer, GetConnectExtensionInfo(uri));
1116     return ret;
1117 }
1118 
MoveItem(Uri & sourceFile,Uri & targetParent,std::vector<Result> & moveResult,bool force)1119 int FileAccessHelper::MoveItem(Uri &sourceFile, Uri &targetParent, std::vector<Result> &moveResult, bool force)
1120 {
1121     UserAccessTracer trace;
1122     trace.Start("MoveItem");
1123     if (!IsSystemApp()) {
1124         HILOG_ERROR("MoveItem check IsSystemAppByFullTokenID failed");
1125         return GetResult("", "", E_PERMISSION_SYS, "", moveResult);
1126     }
1127 
1128     Uri sourceFileUri(sourceFile.ToString());
1129     Uri targetParentUri(targetParent.ToString());
1130     if (!CheckUri(sourceFile) || !CheckUri(targetParent)) {
1131         HILOG_ERROR("uri format check error.");
1132         return GetResult("", "", E_URIS, "", moveResult);
1133     }
1134 
1135     if (sourceFileUri.GetAuthority() != targetParentUri.GetAuthority()) {
1136         HILOG_WARN("Operation failed, move not supported");
1137         return GetResult("", "", EPERM, "", moveResult);
1138     }
1139 
1140     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
1141     if (fileExtProxy == nullptr) {
1142         HILOG_ERROR("failed with invalid fileAccessExtProxy");
1143         return GetResult("", "", E_IPCS, "", moveResult);
1144     }
1145 
1146     int ret = fileExtProxy->MoveItem(sourceFile, targetParent, moveResult, force);
1147     if (ret != ERR_OK) {
1148         HILOG_ERROR("Move get result error, code:%{public}d", ret);
1149         return ret;
1150     }
1151 
1152     return ERR_OK;
1153 }
1154 
MoveFile(Uri & sourceFile,Uri & targetParent,std::string & fileName,Uri & newFile)1155 int FileAccessHelper::MoveFile(Uri &sourceFile, Uri &targetParent, std::string &fileName, Uri &newFile)
1156 {
1157     UserAccessTracer trace;
1158     trace.Start("MoveFile");
1159     if (!IsSystemApp()) {
1160         HILOG_ERROR("FileAccessHelper::MoveFile check IsSystemAppByFullTokenID failed");
1161         return E_PERMISSION_SYS;
1162     }
1163 
1164     Uri sourceFileUri(sourceFile.ToString());
1165     Uri targetParentUri(targetParent.ToString());
1166     if (!CheckUri(sourceFile) || !CheckUri(targetParent)) {
1167         HILOG_ERROR("uri format check error.");
1168         return E_URIS;
1169     }
1170 
1171     if (sourceFileUri.GetAuthority() != targetParentUri.GetAuthority()) {
1172         HILOG_WARN("Operation failed, move not supported");
1173         return EPERM;
1174     }
1175 
1176     sptr<IFileAccessExtBase> fileExtProxy = GetProxyByUri(sourceFile);
1177     if (fileExtProxy == nullptr) {
1178         HILOG_ERROR("failed with invalid fileAccessExtProxy");
1179         return E_IPCS;
1180     }
1181 
1182     int ret = fileExtProxy->MoveFile(sourceFile, targetParent, fileName, newFile);
1183     if (ret != ERR_OK) {
1184         HILOG_ERROR("Move get result error, code:%{public}d", ret);
1185         return ret;
1186     }
1187 
1188     return ERR_OK;
1189 }
1190 } // namespace FileAccessFwk
1191 } // namespace OHOS