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