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_ext_stub_impl.h"
17
18 #include <cinttypes>
19 #include "user_access_tracer.h"
20 #include "file_access_framework_errno.h"
21 #include "hilog_wrapper.h"
22 #include "hitrace_meter.h"
23 #include "access_token.h"
24 #include "accesstoken_kit.h"
25 #include "ipc_skeleton.h"
26
27 namespace OHOS {
28 namespace FileAccessFwk {
29 const uint64_t FILEFILTER_DEFAULT_COUNTS = 2000;
30 const uint64_t FILEFILTER_MAX_COUNTS = 20000;
31 const std::string FILE_ACCESS_MANAGER_PERMISSION = "ohos.permission.FILE_ACCESS_MANAGER";
GetOwner()32 std::shared_ptr<FileAccessExtAbility> FileAccessExtStubImpl::GetOwner()
33 {
34 return extension_;
35 }
36
CheckCallingPermission(const std::string & permission)37 bool FileAccessExtStubImpl::CheckCallingPermission(const std::string &permission)
38 {
39 UserAccessTracer trace;
40 trace.Start("CheckCallingPermission");
41 Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
42 int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission);
43 if (res != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
44 HILOG_ERROR("FileAccessExtStub::CheckCallingPermission have no fileAccess permission");
45 return false;
46 }
47
48 return true;
49 }
50
OpenFile(const Urie & uri,const int flags,int & fd)51 int FileAccessExtStubImpl::OpenFile(const Urie &uri, const int flags, int &fd)
52 {
53 UserAccessTracer trace;
54 trace.Start("OpenFile");
55 if (extension_ == nullptr) {
56 HILOG_ERROR("OpenFile get extension failed.");
57 return E_IPCS;
58 }
59 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
60 HILOG_ERROR("permission error");
61 return E_PERMISSION;
62 }
63 if (flags < 0) {
64 HILOG_ERROR("Parameter OpenFile flags is invalid");
65 return EINVAL;
66 }
67
68 fd = -1;
69 Uri uriConvert(uri.ToString());
70 int ret = extension_->OpenFile(uriConvert, flags, fd);
71 return ret;
72 }
73
CreateFile(const Urie & parent,const std::string & displayName,Urie & newFile)74 int FileAccessExtStubImpl::CreateFile(const Urie &parent, const std::string &displayName, Urie &newFile)
75 {
76 UserAccessTracer trace;
77 trace.Start("CreateFile");
78 if (extension_ == nullptr) {
79 HILOG_ERROR("CreateFile get extension failed.");
80 return E_IPCS;
81 }
82 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
83 HILOG_ERROR("permission error");
84 return E_PERMISSION;
85 }
86
87 Uri parentConvert(parent.ToString());
88 Uri newFileConvert("");
89 int ret = extension_->CreateFile(parentConvert, displayName, newFileConvert);
90 newFile = Urie(newFileConvert.ToString());
91 return ret;
92 }
93
Mkdir(const Urie & parent,const std::string & displayName,Urie & newFile)94 int FileAccessExtStubImpl::Mkdir(const Urie &parent, const std::string &displayName, Urie &newFile)
95 {
96 UserAccessTracer trace;
97 trace.Start("Mkdir");
98 if (extension_ == nullptr) {
99 HILOG_ERROR("Mkdir get extension failed.");
100 return E_IPCS;
101 }
102 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
103 HILOG_ERROR("permission error");
104 return E_PERMISSION;
105 }
106
107 Uri parentConvert(parent.ToString());
108 Uri newFileConvert("");
109 int ret = extension_->Mkdir(parentConvert, displayName, newFileConvert);
110 newFile = Urie(newFileConvert.ToString());
111 return ret;
112 }
113
Delete(const Urie & sourceFile)114 int FileAccessExtStubImpl::Delete(const Urie &sourceFile)
115 {
116 UserAccessTracer trace;
117 trace.Start("Delete");
118 if (extension_ == nullptr) {
119 HILOG_ERROR("Delete get extension failed.");
120 return E_IPCS;
121 }
122 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
123 HILOG_ERROR("permission error");
124 return E_PERMISSION;
125 }
126
127 Uri sourceFileConvert(sourceFile.ToString());
128 int ret = extension_->Delete(sourceFileConvert);
129 return ret;
130 }
131
Move(const Urie & sourceFile,const Urie & targetParent,Urie & newFile)132 int FileAccessExtStubImpl::Move(const Urie &sourceFile, const Urie &targetParent, Urie &newFile)
133 {
134 UserAccessTracer trace;
135 trace.Start("Move");
136 if (extension_ == nullptr) {
137 HILOG_ERROR("Move get extension failed.");
138 return E_IPCS;
139 }
140 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
141 HILOG_ERROR("permission error");
142 return E_PERMISSION;
143 }
144
145 Uri sourceFileConvert(sourceFile.ToString());
146 Uri targetParentConvert(targetParent.ToString());
147 Uri newFileConvert("");
148 int ret = extension_->Move(sourceFileConvert, targetParentConvert, newFileConvert);
149 newFile = Urie(newFileConvert.ToString());
150 return ret;
151 }
152
Copy(const Urie & sourceUri,const Urie & destUri,std::vector<Result> & copyResult,int32_t & retCode,bool force)153 int FileAccessExtStubImpl::Copy(const Urie &sourceUri, const Urie &destUri, std::vector<Result> ©Result,
154 int32_t& retCode, bool force)
155 {
156 UserAccessTracer trace;
157 trace.Start("Copy");
158 if (extension_ == nullptr) {
159 HILOG_ERROR("Copy get extension failed.");
160 return E_IPCS;
161 }
162 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
163 HILOG_ERROR("permission error");
164 return E_PERMISSION;
165 }
166
167 Uri sourceUriConvert(sourceUri.ToString());
168 Uri destUriConvert(destUri.ToString());
169 int ret = extension_->Copy(sourceUriConvert, destUriConvert, copyResult, force);
170 retCode = ret;
171 return ERR_OK;
172 }
173
CopyFile(const Urie & sourceUri,const Urie & destUri,const std::string & fileName,Urie & newFileUri)174 int FileAccessExtStubImpl::CopyFile(const Urie &sourceUri, const Urie &destUri, const std::string &fileName,
175 Urie &newFileUri)
176 {
177 UserAccessTracer trace;
178 trace.Start("CopyFile");
179 if (extension_ == nullptr) {
180 HILOG_ERROR("Copy file get extension failed.");
181 return E_IPCS;
182 }
183 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
184 HILOG_ERROR("permission error");
185 return E_PERMISSION;
186 }
187
188 Uri sourceUriConvert(sourceUri.ToString());
189 Uri destUriConvert(destUri.ToString());
190 Uri newFileUriConvert("");
191 int ret = extension_->CopyFile(sourceUriConvert, destUriConvert, fileName, newFileUriConvert);
192 newFileUri = Urie(newFileUriConvert.ToString());
193 return ret;
194 }
195
Rename(const Urie & sourceFile,const std::string & displayName,Urie & newFile)196 int FileAccessExtStubImpl::Rename(const Urie &sourceFile, const std::string &displayName, Urie &newFile)
197 {
198 UserAccessTracer trace;
199 trace.Start("Rename");
200 if (extension_ == nullptr) {
201 HILOG_ERROR("Rename get extension failed.");
202 return E_IPCS;
203 }
204 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
205 HILOG_ERROR("permission error");
206 return E_PERMISSION;
207 }
208
209 Uri sourceFileConvert(sourceFile.ToString());
210 Uri newFileConvert("");
211 int ret = extension_->Rename(sourceFileConvert, displayName, newFileConvert);
212 newFile = Urie(newFileConvert.ToString());
213 return ret;
214 }
215
ListFile(const FileInfo & fileInfo,const int64_t offset,const FileFilter & filter,SharedMemoryInfo & memInfo)216 int FileAccessExtStubImpl::ListFile(const FileInfo &fileInfo, const int64_t offset,
217 const FileFilter &filter, SharedMemoryInfo &memInfo)
218 {
219 UserAccessTracer trace;
220 trace.Start("ListFile");
221 if (extension_ == nullptr) {
222 HILOG_ERROR("ListFile get extension failed.");
223 return E_IPCS;
224 }
225 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
226 HILOG_ERROR("permission error");
227 return E_PERMISSION;
228 }
229
230 int ret = SharedMemoryOperation::MapSharedMemory(memInfo);
231 if (ret != ERR_OK) {
232 HILOG_ERROR("failed to MapSharedMemory");
233 return ret;
234 }
235
236 std::vector<FileInfo> fileInfoVec;
237 memInfo.isOver = false;
238 int64_t currentOffset = offset;
239 while (true) {
240 uint64_t maxCounts =
241 memInfo.memSize > DEFAULT_CAPACITY_200KB ? FILEFILTER_MAX_COUNTS : FILEFILTER_DEFAULT_COUNTS;
242 fileInfoVec.clear();
243 ret = extension_->ListFile(fileInfo, currentOffset, maxCounts, filter, fileInfoVec);
244 if (ret != ERR_OK) {
245 HILOG_ERROR("Extension ability ListFile error, code:%{public}d", ret);
246 break;
247 }
248
249 uint32_t currentWriteCounts = SharedMemoryOperation::WriteFileInfos(fileInfoVec, memInfo);
250 if (currentWriteCounts < fileInfoVec.size()) {
251 if (memInfo.memSize == DEFAULT_CAPACITY_200KB) {
252 uint32_t counts = 0;
253 extension_->GetFileInfoNum(fileInfo.uri, filter, false, counts);
254 memInfo.leftDataCounts = counts - memInfo.dataCounts;
255 }
256 break;
257 }
258 if (fileInfoVec.empty() ||(maxCounts > static_cast<uint64_t>(fileInfoVec.size())
259 && currentWriteCounts == fileInfoVec.size())) {
260 memInfo.isOver = true;
261 break;
262 }
263 currentOffset += currentWriteCounts;
264 }
265
266 return ret;
267 }
268
ScanFile(const FileInfo & fileInfo,const int64_t offset,const int64_t maxCount,const FileFilter & filter,std::vector<FileInfo> & fileInfoVec)269 int FileAccessExtStubImpl::ScanFile(const FileInfo &fileInfo, const int64_t offset, const int64_t maxCount,
270 const FileFilter &filter, std::vector<FileInfo> &fileInfoVec)
271 {
272 UserAccessTracer trace;
273 trace.Start("ScanFile");
274 if (extension_ == nullptr) {
275 HILOG_ERROR("ScanFile get extension failed.");
276 return E_IPCS;
277 }
278 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
279 HILOG_ERROR("permission error");
280 return E_PERMISSION;
281 }
282
283 int ret = extension_->ScanFile(fileInfo, offset, maxCount, filter, fileInfoVec);
284 return ret;
285 }
286
Query(const Urie & uri,const std::vector<std::string> & columns,std::vector<std::string> & results)287 int FileAccessExtStubImpl::Query(const Urie &uri, const std::vector<std::string> &columns,
288 std::vector<std::string> &results)
289 {
290 UserAccessTracer trace;
291 trace.Start("Query");
292 if (extension_ == nullptr) {
293 HILOG_ERROR("Query get extension failed.");
294 return E_IPCS;
295 }
296 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
297 HILOG_ERROR("permission error");
298 return E_PERMISSION;
299 }
300
301 std::vector<std::string> newColumns = const_cast<std::vector<std::string>&>(columns);
302 Uri uriConvert(uri.ToString());
303 int ret = extension_->Query(uriConvert, newColumns, results);
304 return ret;
305 }
306
GetRoots(std::vector<RootInfo> & rootInfoVec)307 int FileAccessExtStubImpl::GetRoots(std::vector<RootInfo> &rootInfoVec)
308 {
309 UserAccessTracer trace;
310 trace.Start("GetRoots");
311 if (extension_ == nullptr) {
312 HILOG_ERROR("GetRoots get extension failed.");
313 return E_IPCS;
314 }
315 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
316 HILOG_ERROR("permission error");
317 return E_PERMISSION;
318 }
319
320 int ret = extension_->GetRoots(rootInfoVec);
321 return ret;
322 }
323
GetFileInfoFromUri(const Urie & selectFile,FileInfo & fileInfo)324 int FileAccessExtStubImpl::GetFileInfoFromUri(const Urie &selectFile, FileInfo &fileInfo)
325 {
326 UserAccessTracer trace;
327 trace.Start("GetFileInfoFromUri");
328 if (extension_ == nullptr) {
329 HILOG_ERROR("GetFileInfoFromUri get extension failed.");
330 return E_IPCS;
331 }
332 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
333 HILOG_ERROR("permission error");
334 return E_PERMISSION;
335 }
336
337 Uri selectFileConvert(selectFile.ToString());
338 int ret = extension_->GetFileInfoFromUri(selectFileConvert, fileInfo);
339 return ret;
340 }
341
GetFileInfoFromRelativePath(const std::string & selectFile,FileInfo & fileInfo)342 int FileAccessExtStubImpl::GetFileInfoFromRelativePath(const std::string &selectFile, FileInfo &fileInfo)
343 {
344 UserAccessTracer trace;
345 trace.Start("GetFileInfoFromRelativePath");
346 if (extension_ == nullptr) {
347 HILOG_ERROR("GetFileInfoFromRelativePath get extension failed.");
348 return E_IPCS;
349 }
350 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
351 HILOG_ERROR("permission error");
352 return E_PERMISSION;
353 }
354
355 int ret = extension_->GetFileInfoFromRelativePath(selectFile, fileInfo);
356 return ret;
357 }
358
Access(const Urie & uri,bool & isExist)359 int FileAccessExtStubImpl::Access(const Urie &uri, bool &isExist)
360 {
361 UserAccessTracer trace;
362 trace.Start("Access");
363 if (extension_ == nullptr) {
364 HILOG_ERROR("Access get extension failed.");
365 return E_IPCS;
366 }
367 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
368 HILOG_ERROR("permission error");
369 return E_PERMISSION;
370 }
371
372 Uri uriConvert(uri.ToString());
373 int ret = extension_->Access(uriConvert, isExist);
374 return ret;
375 }
376
StartWatcher(const Urie & uri)377 int FileAccessExtStubImpl::StartWatcher(const Urie &uri)
378 {
379 UserAccessTracer trace;
380 trace.Start("StartWatcher");
381 if (extension_ == nullptr) {
382 HILOG_ERROR("StartWatcher get extension failed.");
383 return E_IPCS;
384 }
385 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
386 HILOG_ERROR("permission error");
387 return E_PERMISSION;
388 }
389
390 Uri uriConvert(uri.ToString());
391 int ret = extension_->StartWatcher(uriConvert);
392 return ret;
393 }
394
StopWatcher(const Urie & uri)395 int FileAccessExtStubImpl::StopWatcher(const Urie &uri)
396 {
397 UserAccessTracer trace;
398 trace.Start("StopWatcher");
399 if (extension_ == nullptr) {
400 HILOG_ERROR("StopWatcher get extension failed.");
401 return E_IPCS;
402 }
403 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
404 HILOG_ERROR("permission error");
405 return E_PERMISSION;
406 }
407
408 Uri uriConvert(uri.ToString());
409 int ret = extension_->StopWatcher(uriConvert);
410 return ret;
411 }
412
MoveItem(const Urie & sourceFile,const Urie & targetParent,std::vector<Result> & moveResult,int32_t & retCode,bool force)413 int FileAccessExtStubImpl::MoveItem(const Urie &sourceFile, const Urie &targetParent, std::vector<Result> &moveResult,
414 int32_t& retCode, bool force)
415 {
416 UserAccessTracer trace;
417 trace.Start("MoveItem");
418 if (extension_ == nullptr) {
419 HILOG_ERROR("Move get extension failed.");
420 return E_IPCS;
421 }
422 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
423 HILOG_ERROR("permission error");
424 return E_PERMISSION;
425 }
426
427 Uri sourceFileConvert(sourceFile.ToString());
428 Uri targetParentConvert(targetParent.ToString());
429 int ret = extension_->MoveItem(sourceFileConvert, targetParentConvert, moveResult, force);
430 retCode = ret;
431 return ERR_OK;
432 }
433
MoveFile(const Urie & sourceFile,const Urie & targetParent,const std::string & fileName,Urie & newFile)434 int FileAccessExtStubImpl::MoveFile(const Urie &sourceFile, const Urie &targetParent, const std::string &fileName,
435 Urie &newFile)
436 {
437 UserAccessTracer trace;
438 trace.Start("MoveFile");
439 if (extension_ == nullptr) {
440 HILOG_ERROR("Move get extension failed.");
441 return E_IPCS;
442 }
443 if (!CheckCallingPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
444 HILOG_ERROR("permission error");
445 return E_PERMISSION;
446 }
447
448 std::string newFileName = const_cast<std::string&>(fileName);
449 Uri sourceFileConvert(sourceFile.ToString());
450 Uri targetParentConvert(targetParent.ToString());
451 Uri newFileConvert("");
452 int ret = extension_->MoveFile(sourceFileConvert, targetParentConvert, newFileName, newFileConvert);
453 newFile = Urie(newFileConvert.ToString());
454 return ret;
455 }
456 } // namespace FileAccessFwk
457 } // namespace OHOS
458