1 /*
2  * Copyright (c) 2023 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 #include "ipc/cloud_sync_service_stub.h"
16 #include "cloud_file_sync_service_interface_code.h"
17 #include "dfs_error.h"
18 #include "dfsu_access_token_helper.h"
19 #include "dfsu_memory_guard.h"
20 #include "task_state_manager.h"
21 #include "utils_log.h"
22 
23 namespace OHOS::FileManagement::CloudSync {
24 using namespace std;
25 
26 static const int READ_SIZE = 100;
27 
CloudSyncServiceStub()28 CloudSyncServiceStub::CloudSyncServiceStub()
29 {
30     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_CALLBACK)] =
31         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleUnRegisterCallbackInner(data, reply); };
32     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_CALLBACK)] =
33         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleRegisterCallbackInner(data, reply); };
34     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_SYNC)] =
35         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStartSyncInner(data, reply); };
36     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_TRIGGER_SYNC)] =
37         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleTriggerSyncInner(data, reply); };
38     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_SYNC)] =
39         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStopSyncInner(data, reply); };
40     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CHANGE_APP_SWITCH)] =
41         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleChangeAppSwitch(data, reply); };
42     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN)] =
43         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleClean(data, reply); };
44     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_DATA_CHANGE)] =
45         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleNotifyDataChange(data, reply); };
46     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_EVENT_CHANGE)] =
47         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleNotifyEventChange(data, reply); };
48     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_ENABLE_CLOUD)] =
49         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleEnableCloud(data, reply); };
50     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DISABLE_CLOUD)] =
51         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDisableCloud(data, reply); };
52     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE)] =
53         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStartDownloadFile(data, reply); };
54     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE)] =
55         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStopDownloadFile(data, reply); };
56     opToInterfaceMap_[static_cast<uint32_t>(
57         CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK)] =
58         [this](MessageParcel &data, MessageParcel &reply) {
59             return this->HandleRegisterDownloadFileCallback(data, reply);
60         };
61     opToInterfaceMap_[static_cast<uint32_t>(
62         CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK)] =
63         [this](MessageParcel &data, MessageParcel &reply) {
64             return this->HandleUnregisterDownloadFileCallback(data, reply);
65         };
66     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UPLOAD_ASSET)] =
67         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleUploadAsset(data, reply); };
68     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILE)] =
69         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDownloadFile(data, reply); };
70     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILES)] =
71         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDownloadFiles(data, reply); };
72     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_ASSET)] =
73         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDownloadAsset(data, reply); };
74     opToInterfaceMap_[static_cast<uint32_t>(
75         CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK)] =
76         [this](MessageParcel &data, MessageParcel &reply) {
77             return this->HandleRegisterDownloadAssetCallback(data, reply);
78         };
79     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DELETE_ASSET)] =
80         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDeleteAsset(data, reply); };
81     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_GET_SYNC_TIME)] =
82         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleGetSyncTime(data, reply); };
83     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN_CACHE)] =
84         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleCleanCache(data, reply); };
85     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_FILE_CACHE)] =
86         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStartFileCache(data, reply); };
87     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_RESET_CURSOR)] =
88         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleResetCursor(data, reply); };
89     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_FILE_CACHE)] =
90         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStopFileCache(data, reply); };
91 }
92 
OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)93 int32_t CloudSyncServiceStub::OnRemoteRequest(uint32_t code,
94                                               MessageParcel &data,
95                                               MessageParcel &reply,
96                                               MessageOption &option)
97 {
98     DfsuMemoryGuard cacheGuard;
99     TaskStateManager::GetInstance().StartTask();
100     if (data.ReadInterfaceToken() != GetDescriptor()) {
101         return E_SERVICE_DESCRIPTOR_IS_EMPTY;
102     }
103     auto interfaceIndex = opToInterfaceMap_.find(code);
104     if (interfaceIndex == opToInterfaceMap_.end() || !interfaceIndex->second) {
105         LOGE("Cannot response request %d: unknown tranction", code);
106         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
107     }
108     auto memberFunc = interfaceIndex->second;
109     return memberFunc(data, reply);
110 }
111 
HandleUnRegisterCallbackInner(MessageParcel &data, MessageParcel &reply)112 int32_t CloudSyncServiceStub::HandleUnRegisterCallbackInner(MessageParcel &data, MessageParcel &reply)
113 {
114     LOGI("Begin UnRegisterCallbackInner");
115     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
116         LOGE("permission denied");
117         return E_PERMISSION_DENIED;
118     }
119     if (!DfsuAccessTokenHelper::IsSystemApp()) {
120         LOGE("caller hap is not system hap");
121         return E_PERMISSION_SYSTEM;
122     }
123 
124     string bundleName = data.ReadString();
125     int32_t res = UnRegisterCallbackInner(bundleName);
126     reply.WriteInt32(res);
127     LOGI("End UnRegisterCallbackInner");
128     return E_OK;
129 }
130 
HandleRegisterCallbackInner(MessageParcel &data, MessageParcel &reply)131 int32_t CloudSyncServiceStub::HandleRegisterCallbackInner(MessageParcel &data, MessageParcel &reply)
132 {
133     LOGI("Begin RegisterCallbackInner");
134     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
135         LOGE("permission denied");
136         return E_PERMISSION_DENIED;
137     }
138     if (!DfsuAccessTokenHelper::IsSystemApp()) {
139         LOGE("caller hap is not system hap");
140         return E_PERMISSION_SYSTEM;
141     }
142     auto remoteObj = data.ReadRemoteObject();
143     string bundleName = data.ReadString();
144     int32_t res = RegisterCallbackInner(remoteObj, bundleName);
145     reply.WriteInt32(res);
146     LOGI("End RegisterCallbackInner");
147     return E_OK;
148 }
149 
HandleStartSyncInner(MessageParcel &data, MessageParcel &reply)150 int32_t CloudSyncServiceStub::HandleStartSyncInner(MessageParcel &data, MessageParcel &reply)
151 {
152     LOGI("Begin StartSyncInner");
153     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
154         LOGE("permission denied");
155         return E_PERMISSION_DENIED;
156     }
157     if (!DfsuAccessTokenHelper::IsSystemApp()) {
158         LOGE("caller hap is not system hap");
159         return E_PERMISSION_SYSTEM;
160     }
161     auto forceFlag = data.ReadBool();
162     string bundleName = data.ReadString();
163     int32_t res = StartSyncInner(forceFlag, bundleName);
164     reply.WriteInt32(res);
165     LOGI("End StartSyncInner");
166     return E_OK;
167 }
168 
HandleTriggerSyncInner(MessageParcel &data, MessageParcel &reply)169 int32_t CloudSyncServiceStub::HandleTriggerSyncInner(MessageParcel &data, MessageParcel &reply)
170 {
171     LOGI("Begin TriggerSyncInner");
172     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
173         LOGE("permission denied");
174         return E_PERMISSION_DENIED;
175     }
176     if (!DfsuAccessTokenHelper::IsSystemApp()) {
177         LOGE("caller hap is not system hap");
178         return E_PERMISSION_SYSTEM;
179     }
180     string bundleName = data.ReadString();
181     int32_t userId = data.ReadInt32();
182     int32_t res = TriggerSyncInner(bundleName, userId);
183     reply.WriteInt32(res);
184     LOGI("End TriggerSyncInner");
185     return E_OK;
186 }
187 
HandleStopSyncInner(MessageParcel &data, MessageParcel &reply)188 int32_t CloudSyncServiceStub::HandleStopSyncInner(MessageParcel &data, MessageParcel &reply)
189 {
190     LOGI("Begin StopSyncInner");
191     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
192         LOGE("permission denied");
193         return E_PERMISSION_DENIED;
194     }
195     if (!DfsuAccessTokenHelper::IsSystemApp()) {
196         LOGE("caller hap is not system hap");
197         return E_PERMISSION_SYSTEM;
198     }
199 
200     string bundleName = data.ReadString();
201     bool forceFlag = data.ReadBool();
202     int32_t res = StopSyncInner(bundleName, forceFlag);
203     reply.WriteInt32(res);
204     LOGI("End StopSyncInner");
205     return E_OK;
206 }
207 
HandleResetCursor(MessageParcel &data, MessageParcel &reply)208 int32_t CloudSyncServiceStub::HandleResetCursor(MessageParcel &data, MessageParcel &reply)
209 {
210     LOGI("Begin ResetCursor");
211     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
212         LOGE("permission denied");
213         return E_PERMISSION_DENIED;
214     }
215     if (!DfsuAccessTokenHelper::IsSystemApp()) {
216         LOGE("caller hap is not system hap");
217         return E_PERMISSION_SYSTEM;
218     }
219 
220     string bundleName = data.ReadString();
221     int32_t res = ResetCursor(bundleName);
222     reply.WriteInt32(res);
223     LOGI("End ResetCursor");
224     return E_OK;
225 }
226 
HandleChangeAppSwitch(MessageParcel &data, MessageParcel &reply)227 int32_t CloudSyncServiceStub::HandleChangeAppSwitch(MessageParcel &data, MessageParcel &reply)
228 {
229     LOGI("Begin ChangeAppSwitch");
230     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
231         LOGE("permission denied");
232         return E_PERMISSION_DENIED;
233     }
234     if (!DfsuAccessTokenHelper::IsSystemApp()) {
235         LOGE("caller hap is not system hap");
236         return E_PERMISSION_SYSTEM;
237     }
238     string accountId = data.ReadString();
239     string bundleName = data.ReadString();
240     bool status = data.ReadBool();
241     int32_t res = ChangeAppSwitch(accountId, bundleName, status);
242     reply.WriteInt32(res);
243     LOGI("End ChangeAppSwitch");
244     return E_OK;
245 }
246 
HandleClean(MessageParcel &data, MessageParcel &reply)247 int32_t CloudSyncServiceStub::HandleClean(MessageParcel &data, MessageParcel &reply)
248 {
249     LOGI("Begin Clean");
250     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
251         LOGE("permission denied");
252         return E_PERMISSION_DENIED;
253     }
254     if (!DfsuAccessTokenHelper::IsSystemApp()) {
255         LOGE("caller hap is not system hap");
256         return E_PERMISSION_SYSTEM;
257     }
258     string accountId = data.ReadString();
259     sptr<CleanOptions> options = data.ReadParcelable<CleanOptions>();
260     if (!options) {
261         LOGE("object of CleanOptions is nullptr");
262         return E_INVAL_ARG;
263     }
264     int32_t res = Clean(accountId, *options);
265     reply.WriteInt32(res);
266     LOGI("End Clean");
267     return E_OK;
268 }
269 
HandleNotifyDataChange(MessageParcel &data, MessageParcel &reply)270 int32_t CloudSyncServiceStub::HandleNotifyDataChange(MessageParcel &data, MessageParcel &reply)
271 {
272     LOGI("Begin NotifyDataChange");
273     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
274         LOGE("permission denied");
275         return E_PERMISSION_DENIED;
276     }
277     if (!DfsuAccessTokenHelper::IsSystemApp()) {
278         LOGE("caller hap is not system hap");
279         return E_PERMISSION_SYSTEM;
280     }
281     string accountId = data.ReadString();
282     string bundleName = data.ReadString();
283     int32_t res = NotifyDataChange(accountId, bundleName);
284     reply.WriteInt32(res);
285     LOGI("End NotifyDataChange");
286     return E_OK;
287 }
288 
HandleNotifyEventChange(MessageParcel &data, MessageParcel &reply)289 int32_t CloudSyncServiceStub::HandleNotifyEventChange(MessageParcel &data, MessageParcel &reply)
290 {
291     LOGI("Begin NotifyEventChange");
292     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
293         LOGE("permission denied");
294         return E_PERMISSION_DENIED;
295     }
296     if (!DfsuAccessTokenHelper::IsSystemApp()) {
297         LOGE("caller hap is not system hap");
298         return E_PERMISSION_SYSTEM;
299     }
300     int32_t userId = data.ReadInt32();
301     string eventIdStr = data.ReadString();
302     string extraDataStr = data.ReadString();
303 
304     int32_t res = NotifyEventChange(userId, eventIdStr, extraDataStr);
305     reply.WriteInt32(res);
306     LOGI("End NotifyEventChange");
307     return E_OK;
308 }
309 
HandleDisableCloud(MessageParcel &data, MessageParcel &reply)310 int32_t CloudSyncServiceStub::HandleDisableCloud(MessageParcel &data, MessageParcel &reply)
311 {
312     LOGI("Begin DisableCloud");
313     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
314         LOGE("permission denied");
315         return E_PERMISSION_DENIED;
316     }
317     if (!DfsuAccessTokenHelper::IsSystemApp()) {
318         LOGE("caller hap is not system hap");
319         return E_PERMISSION_SYSTEM;
320     }
321     string accountId = data.ReadString();
322     int32_t res = DisableCloud(accountId);
323     reply.WriteInt32(res);
324     LOGI("End DisableCloud");
325     return E_OK;
326 }
HandleEnableCloud(MessageParcel &data, MessageParcel &reply)327 int32_t CloudSyncServiceStub::HandleEnableCloud(MessageParcel &data, MessageParcel &reply)
328 {
329     LOGI("Begin EnableCloud");
330     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
331         LOGE("permission denied");
332         return E_PERMISSION_DENIED;
333     }
334     if (!DfsuAccessTokenHelper::IsSystemApp()) {
335         LOGE("caller hap is not system hap");
336         return E_PERMISSION_SYSTEM;
337     }
338     string accountId = data.ReadString();
339     sptr<SwitchDataObj> switchObj = data.ReadParcelable<SwitchDataObj>();
340     if (!switchObj) {
341         LOGE("object of SwitchDataObj is nullptr");
342         return E_INVAL_ARG;
343     }
344     int32_t res = EnableCloud(accountId, *switchObj);
345     reply.WriteInt32(res);
346     LOGI("End EnableCloud");
347     return E_OK;
348 }
349 
HandleStartDownloadFile(MessageParcel &data, MessageParcel &reply)350 int32_t CloudSyncServiceStub::HandleStartDownloadFile(MessageParcel &data, MessageParcel &reply)
351 {
352     LOGI("Begin HandleStartDownloadFile");
353     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
354         LOGE("permission denied");
355         return E_PERMISSION_DENIED;
356     }
357     if (!DfsuAccessTokenHelper::IsSystemApp()) {
358         LOGE("caller hap is not system hap");
359         return E_PERMISSION_SYSTEM;
360     }
361     string path = data.ReadString();
362 
363     int32_t res = StartDownloadFile(path);
364     reply.WriteInt32(res);
365     LOGI("End HandleStartDownloadFile");
366     return E_OK;
367 }
368 
HandleStartFileCache(MessageParcel &data, MessageParcel &reply)369 int32_t CloudSyncServiceStub::HandleStartFileCache(MessageParcel &data, MessageParcel &reply)
370 {
371     LOGI("Begin HandleStartFileCache");
372     if (!DfsuAccessTokenHelper::IsSystemApp()) {
373         LOGE("caller hap is not system hap");
374         return E_PERMISSION_SYSTEM;
375     }
376     std::vector<std::string> pathVec;
377     if (!data.ReadStringVector(&pathVec)) {
378         LOGE("Failed to get the cloud id.");
379         return E_INVAL_ARG;
380     }
381 
382     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_AUTH_URI)) {
383         for (int i = 0; i < pathVec.size(); i++) {
384             if (!DfsuAccessTokenHelper::CheckUriPermission(pathVec[i])) {
385                 LOGE("permission denied");
386                 return E_PERMISSION_DENIED;
387             }
388         }
389     }
390     int64_t downloadId = 0;
391     int32_t res = StartFileCache(pathVec, downloadId);
392     reply.WriteInt64(downloadId);
393     reply.WriteInt32(res);
394     LOGI("End HandleStartFileCache");
395     return E_OK;
396 }
397 
HandleStopDownloadFile(MessageParcel &data, MessageParcel &reply)398 int32_t CloudSyncServiceStub::HandleStopDownloadFile(MessageParcel &data, MessageParcel &reply)
399 {
400     LOGI("Begin HandleStopDownloadFile");
401     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
402         LOGE("permission denied");
403         return E_PERMISSION_DENIED;
404     }
405     if (!DfsuAccessTokenHelper::IsSystemApp()) {
406         LOGE("caller hap is not system hap");
407         return E_PERMISSION_SYSTEM;
408     }
409     string path = data.ReadString();
410     bool needClean = data.ReadBool();
411 
412     int32_t res = StopDownloadFile(path, needClean);
413     reply.WriteInt32(res);
414     LOGI("End HandleStopDownloadFile");
415     return E_OK;
416 }
417 
HandleStopFileCache(MessageParcel &data, MessageParcel &reply)418 int32_t CloudSyncServiceStub::HandleStopFileCache(MessageParcel &data, MessageParcel &reply)
419 {
420     LOGI("Begin HandleStopFileCache");
421     if (!DfsuAccessTokenHelper::IsSystemApp()) {
422         LOGE("caller hap is not system hap");
423         return E_PERMISSION_SYSTEM;
424     }
425     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_AUTH_URI)) {
426         LOGE("permission denied");
427         return E_PERMISSION_DENIED;
428     }
429     int64_t downloadId = data.ReadInt64();
430     bool needClean = data.ReadBool();
431 
432     int32_t res = StopFileCache(downloadId, needClean);
433     reply.WriteInt32(res);
434     LOGI("End HandleStopFileCache");
435     return E_OK;
436 }
437 
HandleRegisterDownloadFileCallback(MessageParcel &data, MessageParcel &reply)438 int32_t CloudSyncServiceStub::HandleRegisterDownloadFileCallback(MessageParcel &data, MessageParcel &reply)
439 {
440     LOGI("Begin HandleRegisterDownloadFileCallback");
441     if (!DfsuAccessTokenHelper::IsSystemApp()) {
442         LOGE("caller hap is not system hap");
443         return E_PERMISSION_SYSTEM;
444     }
445 
446     auto downloadCallback = data.ReadRemoteObject();
447 
448     int32_t res = RegisterDownloadFileCallback(downloadCallback);
449     reply.WriteInt32(res);
450     LOGI("End HandleRegisterDownloadFileCallback");
451     return E_OK;
452 }
453 
HandleUnregisterDownloadFileCallback(MessageParcel &data, MessageParcel &reply)454 int32_t CloudSyncServiceStub::HandleUnregisterDownloadFileCallback(MessageParcel &data, MessageParcel &reply)
455 {
456     LOGI("Begin HandleUnregisterDownloadFileCallback");
457     if (!DfsuAccessTokenHelper::IsSystemApp()) {
458         LOGE("caller hap is not system hap");
459         return E_PERMISSION_SYSTEM;
460     }
461 
462     int32_t res = UnregisterDownloadFileCallback();
463     reply.WriteInt32(res);
464     LOGI("End HandleUnregisterDownloadFileCallback");
465     return E_OK;
466 }
467 
HandleUploadAsset(MessageParcel &data, MessageParcel &reply)468 int32_t CloudSyncServiceStub::HandleUploadAsset(MessageParcel &data, MessageParcel &reply)
469 {
470     LOGI("Begin UploadAsset");
471     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
472         LOGE("permission denied");
473         return E_PERMISSION_DENIED;
474     }
475     if (!DfsuAccessTokenHelper::IsSystemApp()) {
476         LOGE("caller hap is not system hap");
477         return E_PERMISSION_SYSTEM;
478     }
479     int32_t userId = data.ReadInt32();
480     string request = data.ReadString();
481     string result;
482     int32_t res = UploadAsset(userId, request, result);
483     reply.WriteInt32(res);
484     reply.WriteString(result);
485     LOGI("End UploadAsset");
486     return E_OK;
487 }
488 
HandleDownloadFile(MessageParcel &data, MessageParcel &reply)489 int32_t CloudSyncServiceStub::HandleDownloadFile(MessageParcel &data, MessageParcel &reply)
490 {
491     LOGI("Begin DownloadFile");
492     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
493         LOGE("permission denied");
494         return E_PERMISSION_DENIED;
495     }
496     if (!DfsuAccessTokenHelper::IsSystemApp()) {
497         LOGE("caller hap is not system hap");
498         return E_PERMISSION_SYSTEM;
499     }
500     int32_t userId = data.ReadInt32();
501     string bundleName = data.ReadString();
502     sptr<AssetInfoObj> assetInfoObj = data.ReadParcelable<AssetInfoObj>();
503     if (!assetInfoObj) {
504         LOGE("object of AssetInfoObj is nullptr");
505         return E_INVAL_ARG;
506     }
507     int32_t res = DownloadFile(userId, bundleName, *assetInfoObj);
508     reply.WriteInt32(res);
509     LOGI("End DownloadFile");
510     return E_OK;
511 }
512 
HandleDownloadFiles(MessageParcel &data, MessageParcel &reply)513 int32_t CloudSyncServiceStub::HandleDownloadFiles(MessageParcel &data, MessageParcel &reply)
514 {
515     LOGI("Begin DownloadFile");
516     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
517         LOGE("permission denied");
518         return E_PERMISSION_DENIED;
519     }
520     if (!DfsuAccessTokenHelper::IsSystemApp()) {
521         LOGE("caller hap is not system hap");
522         return E_PERMISSION_SYSTEM;
523     }
524     int32_t userId = data.ReadInt32();
525     string bundleName = data.ReadString();
526     int32_t size = data.ReadInt32();
527     std::vector<AssetInfoObj> assetInfoObj;
528     if (size > READ_SIZE) {
529         return E_INVAL_ARG;
530     }
531     for (int i = 0; i < size; i++) {
532         sptr<AssetInfoObj> obj = data.ReadParcelable<AssetInfoObj>();
533         if (!obj) {
534             LOGE("object of obj is nullptr");
535             return E_INVAL_ARG;
536         }
537         assetInfoObj.emplace_back(*obj);
538     }
539 
540     std::vector<bool> assetResultMap;
541     int32_t res = DownloadFiles(userId, bundleName, assetInfoObj, assetResultMap);
542     reply.WriteBoolVector(assetResultMap);
543     reply.WriteInt32(res);
544     LOGI("End DownloadFiles");
545     return E_OK;
546 }
547 
HandleDownloadAsset(MessageParcel &data, MessageParcel &reply)548 int32_t CloudSyncServiceStub::HandleDownloadAsset(MessageParcel &data, MessageParcel &reply)
549 {
550     LOGI("Begin DownloadAsset");
551     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
552         LOGE("permission denied");
553         return E_PERMISSION_DENIED;
554     }
555     if (!DfsuAccessTokenHelper::IsSystemApp()) {
556         LOGE("caller hap is not system hap");
557         return E_PERMISSION_SYSTEM;
558     }
559     uint64_t taskId = data.ReadUint64();
560     int32_t userId = data.ReadInt32();
561     string bundleName = data.ReadString();
562     string networkId = data.ReadString();
563     sptr<AssetInfoObj> assetInfoObj = data.ReadParcelable<AssetInfoObj>();
564     if (!assetInfoObj) {
565         LOGE("object of AssetInfoObj is nullptr");
566         return E_INVAL_ARG;
567     }
568     int32_t res = DownloadAsset(taskId, userId, bundleName, networkId, *assetInfoObj);
569     reply.WriteInt32(res);
570     LOGI("End DownloadAsset");
571     return E_OK;
572 }
573 
HandleRegisterDownloadAssetCallback(MessageParcel &data, MessageParcel &reply)574 int32_t CloudSyncServiceStub::HandleRegisterDownloadAssetCallback(MessageParcel &data, MessageParcel &reply)
575 {
576     LOGI("Begin RegisterDownloadAssetCallback");
577     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
578         LOGE("permission denied");
579         return E_PERMISSION_DENIED;
580     }
581     if (!DfsuAccessTokenHelper::IsSystemApp()) {
582         LOGE("caller hap is not system hap");
583         return E_PERMISSION_SYSTEM;
584     }
585     auto remoteObj = data.ReadRemoteObject();
586     int32_t res = RegisterDownloadAssetCallback(remoteObj);
587     reply.WriteInt32(res);
588     LOGI("End RegisterDownloadAssetCallback");
589     return E_OK;
590 }
591 
HandleDeleteAsset(MessageParcel &data, MessageParcel &reply)592 int32_t CloudSyncServiceStub::HandleDeleteAsset(MessageParcel &data, MessageParcel &reply)
593 {
594     LOGI("Begin DeleteAsset");
595     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
596         LOGE("permission denied");
597         return E_PERMISSION_DENIED;
598     }
599     if (!DfsuAccessTokenHelper::IsSystemApp()) {
600         LOGE("caller hap is not system hap");
601         return E_PERMISSION_SYSTEM;
602     }
603     int32_t userId = data.ReadInt32();
604     string uri = data.ReadString();
605     int32_t res = DeleteAsset(userId, uri);
606     reply.WriteInt32(res);
607     reply.WriteString(uri);
608     LOGI("End DeleteAsset");
609     return E_OK;
610 }
611 
HandleGetSyncTime(MessageParcel &data, MessageParcel &reply)612 int32_t CloudSyncServiceStub::HandleGetSyncTime(MessageParcel &data, MessageParcel &reply)
613 {
614     LOGI("Begin GetSyncTime");
615     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
616         LOGE("permission denied");
617         return E_PERMISSION_DENIED;
618     }
619     if (!DfsuAccessTokenHelper::IsSystemApp()) {
620         LOGE("caller hap is not system hap");
621         return E_PERMISSION_SYSTEM;
622     }
623 
624     int64_t syncTime = 0;
625     string bundleName = data.ReadString();
626     int32_t res = GetSyncTimeInner(syncTime, bundleName);
627     reply.WriteInt64(syncTime);
628     reply.WriteInt32(res);
629     return E_OK;
630 }
631 
HandleCleanCache(MessageParcel &data, MessageParcel &reply)632 int32_t CloudSyncServiceStub::HandleCleanCache(MessageParcel &data, MessageParcel &reply)
633 {
634     LOGI("Begin HandleCleanCache");
635     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
636         LOGE("permission denied");
637         return E_PERMISSION_DENIED;
638     }
639     if (!DfsuAccessTokenHelper::IsSystemApp()) {
640         LOGE("caller hap is not system hap");
641         return E_PERMISSION_SYSTEM;
642     }
643 
644     string uri = data.ReadString();
645     int32_t res = CleanCacheInner(uri);
646 
647     reply.WriteInt32(res);
648     return E_OK;
649 }
650 } // namespace OHOS::FileManagement::CloudSync
651