1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "ipc/storage_manager_stub.h"
17 #include "accesstoken_kit.h"
18 #include "ipc_skeleton.h"
19 #include "storage_manager_ipc_interface_code.h"
20 #include "storage_service_errno.h"
21 #include "storage_service_log.h"
22 
23 namespace OHOS {
24 namespace StorageManager {
25 using namespace std;
26 
27 constexpr pid_t ACCOUNT_UID = 3058;
28 constexpr pid_t BACKUP_SA_UID = 1089;
29 constexpr pid_t FOUNDATION_UID = 5523;
30 constexpr pid_t DFS_UID = 1009;
31 const std::string PERMISSION_STORAGE_MANAGER_CRYPT = "ohos.permission.STORAGE_MANAGER_CRYPT";
32 const std::string PERMISSION_STORAGE_MANAGER = "ohos.permission.STORAGE_MANAGER";
33 const std::string PERMISSION_MOUNT_MANAGER = "ohos.permission.MOUNT_UNMOUNT_MANAGER";
34 const std::string PERMISSION_FORMAT_MANAGER = "ohos.permission.MOUNT_FORMAT_MANAGER";
35 const std::string PROCESS_NAME_FOUNDATION = "foundation";
36 
CheckClientPermission(const std::string & permissionStr)37 bool CheckClientPermission(const std::string& permissionStr)
38 {
39     Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
40     auto uid = IPCSkeleton::GetCallingUid();
41     auto tokenType = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenCaller);
42     int res;
43     if (tokenType == Security::AccessToken::TOKEN_NATIVE && uid == ACCOUNT_UID) {
44         res = Security::AccessToken::PermissionState::PERMISSION_GRANTED;
45     } else {
46         res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permissionStr);
47     }
48 
49     if (res == Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
50         LOGD("StorageMangaer permissionCheck pass!");
51         return true;
52     }
53     LOGE("StorageManager permissionCheck error, need %{public}s", permissionStr.c_str());
54     return false;
55 }
56 
CheckClientPermissionForCrypt(const std::string & permissionStr)57 bool CheckClientPermissionForCrypt(const std::string& permissionStr)
58 {
59     Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
60     int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permissionStr);
61     if (res == Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
62         LOGD("StorageMangaer permissionCheck pass!");
63         return true;
64     }
65     LOGE("StorageManager permissionCheck error, need %{public}s", permissionStr.c_str());
66     return false;
67 }
68 
CheckClientPermissionForShareFile()69 bool CheckClientPermissionForShareFile()
70 {
71     Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
72     Security::AccessToken::NativeTokenInfo nativeInfo;
73     Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(tokenCaller, nativeInfo);
74 
75     auto uid = IPCSkeleton::GetCallingUid();
76     if (nativeInfo.processName != PROCESS_NAME_FOUNDATION || uid != FOUNDATION_UID) {
77         LOGE("CheckClientPermissionForShareFile error, processName is %{public}s, uid is %{public}d",
78             nativeInfo.processName.c_str(), uid);
79         return false;
80     }
81 
82     return true;
83 }
84 
StorageManagerStub()85 StorageManagerStub::StorageManagerStub()
86 {
87     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::PREPARE_ADD_USER)] =
88         &StorageManagerStub::HandlePrepareAddUser;
89     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::REMOVE_USER)] =
90         &StorageManagerStub::HandleRemoveUser;
91     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::PREPARE_START_USER)] =
92         &StorageManagerStub::HandlePrepareStartUser;
93     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::STOP_USER)] =
94         &StorageManagerStub::HandleStopUser;
95     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_TOTAL)] =
96         &StorageManagerStub::HandleGetTotal;
97     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_FREE)] =
98         &StorageManagerStub::HandleGetFree;
99     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_SYSTEM_SIZE)] =
100         &StorageManagerStub::HandleGetSystemSize;
101     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_TOTAL_SIZE)] =
102         &StorageManagerStub::HandleGetTotalSize;
103     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_FREE_SIZE)] =
104         &StorageManagerStub::HandleGetFreeSize;
105     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_CURR_USER_STATS)] =
106         &StorageManagerStub::HandleGetCurrUserStorageStats;
107     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_USER_STATS)] =
108         &StorageManagerStub::HandleGetUserStorageStats;
109     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_USER_STATS_BY_TYPE)] =
110         &StorageManagerStub::HandleGetUserStorageStatsByType;
111     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_CURR_BUNDLE_STATS)] =
112         &StorageManagerStub::HandleGetCurrentBundleStats;
113     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_BUNDLE_STATUS)] =
114         &StorageManagerStub::HandleGetBundleStatus;
115     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_VOLUME_CREATED)] =
116         &StorageManagerStub::HandleNotifyVolumeCreated;
117     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_VOLUME_MOUNTED)] =
118         &StorageManagerStub::HandleNotifyVolumeMounted;
119     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_VOLUME_STATE_CHANGED)] =
120         &StorageManagerStub::HandleNotifyVolumeStateChanged;
121     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::MOUNT)] =
122         &StorageManagerStub::HandleMount;
123     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::UNMOUNT)] =
124         &StorageManagerStub::HandleUnmount;
125     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_ALL_VOLUMES)] =
126         &StorageManagerStub::HandleGetAllVolumes;
127     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_DISK_CREATED)] =
128         &StorageManagerStub::HandleNotifyDiskCreated;
129     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_DISK_DESTROYED)] =
130         &StorageManagerStub::HandleNotifyDiskDestroyed;
131     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::PARTITION)] =
132         &StorageManagerStub::HandlePartition;
133     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_ALL_DISKS)] =
134         &StorageManagerStub::HandleGetAllDisks;
135     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_VOL_BY_UUID)] =
136         &StorageManagerStub::HandleGetVolumeByUuid;
137     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_VOL_BY_ID)] =
138         &StorageManagerStub::HandleGetVolumeById;
139     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::SET_VOL_DESC)] =
140         &StorageManagerStub::HandleSetVolDesc;
141     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::FORMAT)] =
142         &StorageManagerStub::HandleFormat;
143     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_DISK_BY_ID)] =
144         &StorageManagerStub::HandleGetDiskById;
145     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::CREATE_USER_KEYS)] =
146         &StorageManagerStub::HandleGenerateUserKeys;
147     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::DELETE_USER_KEYS)] =
148         &StorageManagerStub::HandleDeleteUserKeys;
149     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::UPDATE_USER_AUTH)] =
150         &StorageManagerStub::HandleUpdateUserAuth;
151     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::ACTIVE_USER_KEY)] =
152         &StorageManagerStub::HandleActiveUserKey;
153     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::INACTIVE_USER_KEY)] =
154         &StorageManagerStub::HandleInactiveUserKey;
155     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::LOCK_USER_SCREEN)] =
156         &StorageManagerStub::HandleLockUserScreen;
157     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::UNLOCK_USER_SCREEN)] =
158         &StorageManagerStub::HandleUnlockUserScreen;
159     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::LOCK_SCREEN_STATUS)] =
160         &StorageManagerStub::HandleGetLockScreenStatus;
161     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::UPDATE_KEY_CONTEXT)] =
162         &StorageManagerStub::HandleUpdateKeyContext;
163     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::CREATE_SHARE_FILE)] =
164         &StorageManagerStub::HandleCreateShareFile;
165     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::DELETE_SHARE_FILE)] =
166         &StorageManagerStub::HandleDeleteShareFile;
167     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::SET_BUNDLE_QUOTA)] =
168         &StorageManagerStub::HandleSetBundleQuota;
169     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::UPDATE_MEM_PARA)] =
170         &StorageManagerStub::HandleUpdateMemoryPara;
171     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_BUNDLE_STATS_INCREASE)] =
172         &StorageManagerStub::HandleGetBundleStatsForIncrease;
173     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GENERATE_APP_KEY)] =
174         &StorageManagerStub::HandleGenerateAppkey;
175     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::DELETE_APP_KEY)] =
176         &StorageManagerStub::HandleDeleteAppkey;
177     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::MOUNT_DFS_DOCS)] =
178         &StorageManagerStub::HandleMountDfsDocs;
179     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::UMOUNT_DFS_DOCS)] =
180         &StorageManagerStub::HandleUMountDfsDocs;
181     opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::GET_FILE_ENCRYPT_STATUS)] =
182         &StorageManagerStub::HandleGetFileEncryptStatus;
183 }
184 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)185 int32_t StorageManagerStub::OnRemoteRequest(uint32_t code,
186     MessageParcel &data, MessageParcel &reply, MessageOption &option)
187 {
188     if (data.ReadInterfaceToken() != GetDescriptor()) {
189         return E_PERMISSION_DENIED;
190     }
191     switch (code) {
192         case static_cast<uint32_t>(StorageManagerInterfaceCode::PREPARE_ADD_USER):
193             return HandlePrepareAddUser(data, reply);
194         case static_cast<uint32_t>(StorageManagerInterfaceCode::REMOVE_USER):
195             return HandleRemoveUser(data, reply);
196         case static_cast<uint32_t>(StorageManagerInterfaceCode::PREPARE_START_USER):
197             return HandlePrepareStartUser(data, reply);
198         case static_cast<uint32_t>(StorageManagerInterfaceCode::STOP_USER):
199             return HandleStopUser(data, reply);
200         case static_cast<uint32_t>(StorageManagerInterfaceCode::COMPLETE_ADD_USER):
201             return HandleCompleteAddUser(data, reply);
202         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_TOTAL):
203             return HandleGetTotal(data, reply);
204         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_FREE):
205             return HandleGetFree(data, reply);
206         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_SYSTEM_SIZE):
207             return HandleGetSystemSize(data, reply);
208         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_TOTAL_SIZE):
209             return HandleGetTotalSize(data, reply);
210         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_FREE_SIZE):
211             return HandleGetFreeSize(data, reply);
212         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_CURR_USER_STATS):
213             return HandleGetCurrUserStorageStats(data, reply);
214         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_USER_STATS):
215             return HandleGetUserStorageStats(data, reply);
216         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_USER_STATS_BY_TYPE):
217             return HandleGetUserStorageStatsByType(data, reply);
218         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_CURR_BUNDLE_STATS):
219             return HandleGetCurrentBundleStats(data, reply);
220         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_BUNDLE_STATUS):
221             return HandleGetBundleStatus(data, reply);
222         case static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_VOLUME_CREATED):
223             return HandleNotifyVolumeCreated(data, reply);
224         case static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_VOLUME_MOUNTED):
225             return HandleNotifyVolumeMounted(data, reply);
226         case static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_VOLUME_STATE_CHANGED):
227             return HandleNotifyVolumeStateChanged(data, reply);
228         case static_cast<uint32_t>(StorageManagerInterfaceCode::MOUNT):
229             return HandleMount(data, reply);
230         case static_cast<uint32_t>(StorageManagerInterfaceCode::UNMOUNT):
231             return HandleUnmount(data, reply);
232         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_ALL_VOLUMES):
233             return HandleGetAllVolumes(data, reply);
234         case static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_DISK_CREATED):
235             return HandleNotifyDiskCreated(data, reply);
236         case static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_DISK_DESTROYED):
237             return HandleNotifyDiskDestroyed(data, reply);
238         case static_cast<uint32_t>(StorageManagerInterfaceCode::PARTITION):
239             return HandlePartition(data, reply);
240         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_ALL_DISKS):
241             return HandleGetAllDisks(data, reply);
242         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_VOL_BY_UUID):
243             return HandleGetVolumeByUuid(data, reply);
244         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_VOL_BY_ID):
245             return HandleGetVolumeById(data, reply);
246         case static_cast<uint32_t>(StorageManagerInterfaceCode::SET_VOL_DESC):
247             return HandleSetVolDesc(data, reply);
248         case static_cast<uint32_t>(StorageManagerInterfaceCode::FORMAT):
249             return HandleFormat(data, reply);
250         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_DISK_BY_ID):
251             return HandleGetDiskById(data, reply);
252         case static_cast<uint32_t>(StorageManagerInterfaceCode::CREATE_USER_KEYS):
253             return HandleGenerateUserKeys(data, reply);
254         case static_cast<uint32_t>(StorageManagerInterfaceCode::DELETE_USER_KEYS):
255             return HandleDeleteUserKeys(data, reply);
256         case static_cast<uint32_t>(StorageManagerInterfaceCode::UPDATE_USER_AUTH):
257             return HandleUpdateUserAuth(data, reply);
258         case static_cast<uint32_t>(StorageManagerInterfaceCode::ACTIVE_USER_KEY):
259             return HandleActiveUserKey(data, reply);
260         case static_cast<uint32_t>(StorageManagerInterfaceCode::INACTIVE_USER_KEY):
261             return HandleInactiveUserKey(data, reply);
262         case static_cast<uint32_t>(StorageManagerInterfaceCode::LOCK_USER_SCREEN):
263             return HandleLockUserScreen(data, reply);
264         case static_cast<uint32_t>(StorageManagerInterfaceCode::UNLOCK_USER_SCREEN):
265             return HandleUnlockUserScreen(data, reply);
266         case static_cast<uint32_t>(StorageManagerInterfaceCode::LOCK_SCREEN_STATUS):
267             return HandleGetLockScreenStatus(data, reply);
268         case static_cast<uint32_t>(StorageManagerInterfaceCode::UPDATE_KEY_CONTEXT):
269             return HandleUpdateKeyContext(data, reply);
270         case static_cast<uint32_t>(StorageManagerInterfaceCode::CREATE_SHARE_FILE):
271             return HandleCreateShareFile(data, reply);
272         case static_cast<uint32_t>(StorageManagerInterfaceCode::DELETE_SHARE_FILE):
273             return HandleDeleteShareFile(data, reply);
274         case static_cast<uint32_t>(StorageManagerInterfaceCode::SET_BUNDLE_QUOTA):
275             return HandleSetBundleQuota(data, reply);
276         case static_cast<uint32_t>(StorageManagerInterfaceCode::UPDATE_MEM_PARA):
277             return HandleUpdateMemoryPara(data, reply);
278         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_BUNDLE_STATS_INCREASE):
279             return HandleGetBundleStatsForIncrease(data, reply);
280         case static_cast<uint32_t>(StorageManagerInterfaceCode::MOUNT_DFS_DOCS):
281             return HandleMountDfsDocs(data, reply);
282         case static_cast<uint32_t>(StorageManagerInterfaceCode::UMOUNT_DFS_DOCS):
283             return HandleUMountDfsDocs(data, reply);
284         case static_cast<uint32_t>(StorageManagerInterfaceCode::GENERATE_APP_KEY):
285             return HandleGenerateAppkey(data, reply);
286         case static_cast<uint32_t>(StorageManagerInterfaceCode::DELETE_APP_KEY):
287             return HandleDeleteAppkey(data, reply);
288         case static_cast<uint32_t>(StorageManagerInterfaceCode::GET_FILE_ENCRYPT_STATUS):
289             return HandleGetFileEncryptStatus(data, reply);
290         default:
291             LOGE("Cannot response request %d: unknown tranction", code);
292             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
293     }
294 }
295 
HandlePrepareAddUser(MessageParcel & data,MessageParcel & reply)296 int32_t StorageManagerStub::HandlePrepareAddUser(MessageParcel &data, MessageParcel &reply)
297 {
298     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
299         return E_PERMISSION_DENIED;
300     }
301     int32_t userId = data.ReadInt32();
302     uint32_t flags = data.ReadUint32();
303     LOGI("StorageManagerStub::HandlePrepareAddUser, userId:%{public}d", userId);
304     int err = PrepareAddUser(userId, flags);
305     if (!reply.WriteUint32(err)) {
306         LOGE("StorageManagerStub::HandlePrepareAddUser call PrepareAddUser failed");
307         return  E_WRITE_REPLY_ERR;
308     }
309     return E_OK;
310 }
311 
HandleRemoveUser(MessageParcel & data,MessageParcel & reply)312 int32_t StorageManagerStub::HandleRemoveUser(MessageParcel &data, MessageParcel &reply)
313 {
314     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
315         return E_PERMISSION_DENIED;
316     }
317     int32_t userId = data.ReadInt32();
318     uint32_t flags = data.ReadUint32();
319     LOGI("StorageManagerStub::HandleRemoveUser, userId:%{public}d", userId);
320     int err = RemoveUser(userId, flags);
321     if (!reply.WriteUint32(err)) {
322         LOGE("StorageManagerStub::HandleRemoveUser call RemoveUser failed");
323         return E_WRITE_REPLY_ERR;
324     }
325     return E_OK;
326 }
327 
HandlePrepareStartUser(MessageParcel & data,MessageParcel & reply)328 int32_t StorageManagerStub::HandlePrepareStartUser(MessageParcel &data, MessageParcel &reply)
329 {
330     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
331         return E_PERMISSION_DENIED;
332     }
333     int32_t userId = data.ReadInt32();
334     LOGI("StorageManagerStub::HandlePrepareStartUser, userId:%{public}d", userId);
335     int err = PrepareStartUser(userId);
336     if (!reply.WriteUint32(err)) {
337         LOGE("StorageManagerStub::HandlePrepareStartUser call PrepareStartUser failed");
338         return E_WRITE_REPLY_ERR;
339     }
340     return E_OK;
341 }
342 
HandleStopUser(MessageParcel & data,MessageParcel & reply)343 int32_t StorageManagerStub::HandleStopUser(MessageParcel &data, MessageParcel &reply)
344 {
345     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
346         return E_PERMISSION_DENIED;
347     }
348     int32_t userId = data.ReadInt32();
349     LOGI("StorageManagerStub::HandleStopUser, userId:%{public}d", userId);
350     int err = StopUser(userId);
351     if (!reply.WriteUint32(err)) {
352         LOGE("StorageManagerStub::HandleStopUser call StopUser failed");
353         return E_WRITE_REPLY_ERR;
354     }
355     return E_OK;
356 }
357 
HandleCompleteAddUser(MessageParcel & data,MessageParcel & reply)358 int32_t StorageManagerStub::HandleCompleteAddUser(MessageParcel &data, MessageParcel &reply)
359 {
360     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
361         return E_PERMISSION_DENIED;
362     }
363     int32_t userId = data.ReadInt32();
364     LOGI("StorageManagerStub::HandleCompleteAddUser, userId:%{public}d", userId);
365     int err = CompleteAddUser(userId);
366     if (!reply.WriteUint32(err)) {
367         LOGE("StorageManagerStub::HandleCompleteAddUser call CompleteAddUser failed");
368         return E_WRITE_REPLY_ERR;
369     }
370     return E_OK;
371 }
372 
HandleGetTotal(MessageParcel & data,MessageParcel & reply)373 int32_t StorageManagerStub::HandleGetTotal(MessageParcel &data, MessageParcel &reply)
374 {
375     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
376         return E_PERMISSION_DENIED;
377     }
378     LOGE("StorageManagerStub::HandleGetTotal Begin.");
379     std::string volumeId = data.ReadString();
380     int64_t totalSize;
381     int32_t err = GetTotalSizeOfVolume(volumeId, totalSize);
382     if (!reply.WriteInt32(err)) {
383         LOGE("StorageManagerStub::HandleGetTotal call OnUserDGetTotalSizeOfVolume failed");
384         return  E_WRITE_REPLY_ERR;
385     }
386     if (!reply.WriteInt64(totalSize)) {
387         return  E_WRITE_REPLY_ERR;
388     }
389     return E_OK;
390 }
391 
HandleGetFree(MessageParcel & data,MessageParcel & reply)392 int32_t StorageManagerStub::HandleGetFree(MessageParcel &data, MessageParcel &reply)
393 {
394     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
395         return E_PERMISSION_DENIED;
396     }
397     std::string volumeId = data.ReadString();
398     int64_t freeSize;
399     int32_t err = GetFreeSizeOfVolume(volumeId, freeSize);
400     if (!reply.WriteInt32(err)) {
401         LOGE("StorageManagerStub::HandleGetFree call GetFreeSizeOfVolume failed");
402         return  E_WRITE_REPLY_ERR;
403     }
404     if (!reply.WriteInt64(freeSize)) {
405         return  E_WRITE_REPLY_ERR;
406     }
407     return E_OK;
408 }
409 
HandleGetBundleStatus(MessageParcel & data,MessageParcel & reply)410 int32_t StorageManagerStub::HandleGetBundleStatus(MessageParcel &data, MessageParcel &reply)
411 {
412     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
413         return E_PERMISSION_DENIED;
414     }
415     std::string pkgName = data.ReadString();
416     int32_t appIndex = data.ReadInt32();
417     uint32_t statFlag = data.ReadUint32();
418     BundleStats bundleStats;
419     int32_t err = GetBundleStats(pkgName, bundleStats, appIndex, statFlag);
420     if (!reply.WriteInt32(err)) {
421         return  E_WRITE_REPLY_ERR;
422     }
423     if (!bundleStats.Marshalling(reply)) {
424         return  E_WRITE_REPLY_ERR;
425     }
426     return E_OK;
427 }
428 
HandleGetSystemSize(MessageParcel & data,MessageParcel & reply)429 int32_t StorageManagerStub::HandleGetSystemSize(MessageParcel &data, MessageParcel &reply)
430 {
431     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
432         return E_PERMISSION_DENIED;
433     }
434     int64_t systemSize;
435     int32_t err = GetSystemSize(systemSize);
436     if (!reply.WriteInt32(err)) {
437         return  E_WRITE_REPLY_ERR;
438     }
439     if (!reply.WriteInt64(systemSize)) {
440         LOGE("StorageManagerStub::HandleGetFree call GetSystemSize failed");
441         return  E_WRITE_REPLY_ERR;
442     }
443     return E_OK;
444 }
445 
HandleGetTotalSize(MessageParcel & data,MessageParcel & reply)446 int32_t StorageManagerStub::HandleGetTotalSize(MessageParcel &data, MessageParcel &reply)
447 {
448     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
449         return E_PERMISSION_DENIED;
450     }
451     int64_t totalSize;
452     int32_t err = GetTotalSize(totalSize);
453     if (!reply.WriteInt32(err)) {
454         return  E_WRITE_REPLY_ERR;
455     }
456     if (!reply.WriteInt64(totalSize)) {
457         LOGE("StorageManagerStub::HandleGetFree call GetTotalSize failed");
458         return  E_WRITE_REPLY_ERR;
459     }
460     return E_OK;
461 }
462 
HandleGetFreeSize(MessageParcel & data,MessageParcel & reply)463 int32_t StorageManagerStub::HandleGetFreeSize(MessageParcel &data, MessageParcel &reply)
464 {
465     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
466         return E_PERMISSION_DENIED;
467     }
468     int64_t freeSize;
469     int32_t err = GetFreeSize(freeSize);
470     if (!reply.WriteInt32(err)) {
471         return  E_WRITE_REPLY_ERR;
472     }
473     if (!reply.WriteInt64(freeSize)) {
474         LOGE("StorageManagerStub::HandleGetFree call GetFreeSize failed");
475         return  E_WRITE_REPLY_ERR;
476     }
477     return E_OK;
478 }
479 
HandleGetCurrUserStorageStats(MessageParcel & data,MessageParcel & reply)480 int32_t StorageManagerStub::HandleGetCurrUserStorageStats(MessageParcel &data, MessageParcel &reply)
481 {
482     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
483         return E_PERMISSION_DENIED;
484     }
485     StorageStats storageStats;
486     int32_t err = GetUserStorageStats(storageStats);
487     if (!reply.WriteInt32(err)) {
488         return  E_WRITE_REPLY_ERR;
489     }
490     if (!storageStats.Marshalling(reply)) {
491         return  E_WRITE_REPLY_ERR;
492     }
493     return E_OK;
494 }
495 
HandleGetUserStorageStats(MessageParcel & data,MessageParcel & reply)496 int32_t StorageManagerStub::HandleGetUserStorageStats(MessageParcel &data, MessageParcel &reply)
497 {
498     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
499         return E_PERMISSION_DENIED;
500     }
501     int32_t userId = data.ReadInt32();
502     StorageStats storageStats;
503     int32_t err = GetUserStorageStats(userId, storageStats);
504     if (!reply.WriteInt32(err)) {
505         return  E_WRITE_REPLY_ERR;
506     }
507     if (!storageStats.Marshalling(reply)) {
508         return  E_WRITE_REPLY_ERR;
509     }
510     return E_OK;
511 }
512 
HandleGetCurrentBundleStats(MessageParcel & data,MessageParcel & reply)513 int32_t StorageManagerStub::HandleGetCurrentBundleStats(MessageParcel &data, MessageParcel &reply)
514 {
515     BundleStats bundleStats;
516     uint32_t statFlag = data.ReadUint32();
517     int32_t err = GetCurrentBundleStats(bundleStats, statFlag);
518     if (!reply.WriteInt32(err)) {
519         return  E_WRITE_REPLY_ERR;
520     }
521     if (!bundleStats.Marshalling(reply)) {
522         return  E_WRITE_REPLY_ERR;
523     }
524     return E_OK;
525 }
526 
HandleGetAllVolumes(MessageParcel & data,MessageParcel & reply)527 int32_t StorageManagerStub::HandleGetAllVolumes(MessageParcel &data, MessageParcel &reply)
528 {
529     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
530         return E_PERMISSION_DENIED;
531     }
532     std::vector<VolumeExternal> ve;
533     int32_t err = GetAllVolumes(ve);
534     if (!reply.WriteInt32(err)) {
535         return  E_WRITE_REPLY_ERR;
536     }
537     uint size = ve.size();
538     if (size == 0) {
539         LOGE("StorageManagerStub::No volume.");
540         if (!reply.WriteUint32(0)) {
541             return  E_WRITE_REPLY_ERR;
542         }
543         return E_OK;
544     }
545     if (!reply.WriteUint32(ve.size())) {
546         return  E_WRITE_REPLY_ERR;
547     }
548     for (uint i = 0; i < size; i++) {
549         if (!ve[i].Marshalling(reply)) {
550             return  E_WRITE_REPLY_ERR;
551         }
552     }
553     return E_OK;
554 }
555 
HandleNotifyVolumeCreated(MessageParcel & data,MessageParcel & reply)556 int32_t StorageManagerStub::HandleNotifyVolumeCreated(MessageParcel &data, MessageParcel &reply)
557 {
558     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
559         return E_PERMISSION_DENIED;
560     }
561     std::unique_ptr<VolumeCore> vc = VolumeCore::Unmarshalling(data);
562     NotifyVolumeCreated(*vc);
563     LOGI("StorageManagerStub::HandleNotifyVolumeCreated");
564     return E_OK;
565 }
566 
HandleNotifyVolumeMounted(MessageParcel & data,MessageParcel & reply)567 int32_t StorageManagerStub::HandleNotifyVolumeMounted(MessageParcel &data, MessageParcel &reply)
568 {
569     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
570         return E_PERMISSION_DENIED;
571     }
572     std::string volumeId = data.ReadString();
573     int32_t fsType = data.ReadInt32();
574     std::string fsUuid = data.ReadString();
575     std::string path = data.ReadString();
576     std::string description = data.ReadString();
577     NotifyVolumeMounted(volumeId, fsType, fsUuid, path, description);
578     LOGI("StorageManagerStub::HandleNotifyVolumeMounted");
579     return E_OK;
580 }
581 
HandleNotifyVolumeStateChanged(MessageParcel & data,MessageParcel & reply)582 int32_t StorageManagerStub::HandleNotifyVolumeStateChanged(MessageParcel &data, MessageParcel &reply)
583 {
584     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
585         return E_PERMISSION_DENIED;
586     }
587     std::string volumeId = data.ReadString();
588     VolumeState state = VolumeState(data.ReadInt32());
589     NotifyVolumeStateChanged(volumeId, state);
590     LOGI("StorageManagerStub::HandleNotifyVolumeStateChanged");
591     return E_OK;
592 }
593 
HandleMount(MessageParcel & data,MessageParcel & reply)594 int32_t StorageManagerStub::HandleMount(MessageParcel &data, MessageParcel &reply)
595 {
596     if (!CheckClientPermission(PERMISSION_MOUNT_MANAGER)) {
597         return E_PERMISSION_DENIED;
598     }
599     std::string volumeId = data.ReadString();
600     int err = Mount(volumeId);
601     if (!reply.WriteUint32(err)) {
602         LOGE("StorageManagerStub::HandleMount call Mount failed");
603         return  E_WRITE_REPLY_ERR;
604     }
605     return E_OK;
606 }
607 
HandleUnmount(MessageParcel & data,MessageParcel & reply)608 int32_t StorageManagerStub::HandleUnmount(MessageParcel &data, MessageParcel &reply)
609 {
610     if (!CheckClientPermission(PERMISSION_MOUNT_MANAGER)) {
611         return E_PERMISSION_DENIED;
612     }
613     std::string volumeId = data.ReadString();
614     int err = Unmount(volumeId);
615     if (!reply.WriteUint32(err)) {
616         LOGE("StorageManagerStub::HandleUnmount call Mount failed");
617         return  E_WRITE_REPLY_ERR;
618     }
619     return E_OK;
620 }
621 
HandleNotifyDiskCreated(MessageParcel & data,MessageParcel & reply)622 int32_t StorageManagerStub::HandleNotifyDiskCreated(MessageParcel &data, MessageParcel &reply)
623 {
624     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
625         return E_PERMISSION_DENIED;
626     }
627     auto disk = Disk::Unmarshalling(data);
628     NotifyDiskCreated(*disk);
629     return E_OK;
630 }
631 
HandleNotifyDiskDestroyed(MessageParcel & data,MessageParcel & reply)632 int32_t StorageManagerStub::HandleNotifyDiskDestroyed(MessageParcel &data, MessageParcel &reply)
633 {
634     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
635         return E_PERMISSION_DENIED;
636     }
637     std::string diskId = data.ReadString();
638     NotifyDiskDestroyed(diskId);
639     return E_OK;
640 }
641 
HandlePartition(MessageParcel & data,MessageParcel & reply)642 int32_t StorageManagerStub::HandlePartition(MessageParcel &data, MessageParcel &reply)
643 {
644     if (!CheckClientPermission(PERMISSION_FORMAT_MANAGER)) {
645         return E_PERMISSION_DENIED;
646     }
647     std::string diskId = data.ReadString();
648     int32_t type = data.ReadInt32();
649     int err = Partition(diskId, type);
650     if (!reply.WriteUint32(err)) {
651         LOGE("StorageManagerStub::HandlePartition call Partition failed");
652         return E_WRITE_REPLY_ERR;
653     }
654     return E_OK;
655 }
656 
HandleGetAllDisks(MessageParcel & data,MessageParcel & reply)657 int32_t StorageManagerStub::HandleGetAllDisks(MessageParcel &data, MessageParcel &reply)
658 {
659     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
660         return E_PERMISSION_DENIED;
661     }
662     std::vector<Disk> disks;
663     int32_t err = GetAllDisks(disks);
664     if (!reply.WriteUint32(err)) {
665         return E_WRITE_REPLY_ERR;
666     }
667     uint size = disks.size();
668     if (size == 0) {
669         LOGE("StorageManagerStub::No Disk.");
670         if (!reply.WriteUint32(0)) {
671             return  E_WRITE_REPLY_ERR;
672         }
673         return E_OK;
674     }
675     if (!reply.WriteUint32(disks.size())) {
676         return  E_WRITE_REPLY_ERR;
677     }
678     for (uint i = 0; i < size; i++) {
679         if (!disks[i].Marshalling(reply)) {
680             return  E_WRITE_REPLY_ERR;
681         }
682     }
683     return E_OK;
684 }
685 
HandleGetVolumeByUuid(MessageParcel & data,MessageParcel & reply)686 int32_t StorageManagerStub::HandleGetVolumeByUuid(MessageParcel &data, MessageParcel &reply)
687 {
688     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
689         return E_PERMISSION_DENIED;
690     }
691     std::string fsUuid = data.ReadString();
692     VolumeExternal vc;
693     int err = GetVolumeByUuid(fsUuid, vc);
694     if (!vc.Marshalling(reply)) {
695         return E_WRITE_REPLY_ERR;
696     }
697     if (!reply.WriteUint32(err)) {
698         LOGE("StorageManagerStub::HandleGetVolumeByUuid call GetVolumeByUuid failed");
699         return E_WRITE_REPLY_ERR;
700     }
701     return E_OK;
702 }
703 
HandleGetVolumeById(MessageParcel & data,MessageParcel & reply)704 int32_t StorageManagerStub::HandleGetVolumeById(MessageParcel &data, MessageParcel &reply)
705 {
706     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
707         return E_PERMISSION_DENIED;
708     }
709     std::string volId = data.ReadString();
710     VolumeExternal vc;
711     int err = GetVolumeById(volId, vc);
712     if (!vc.Marshalling(reply)) {
713         return E_WRITE_REPLY_ERR;
714     }
715     if (!reply.WriteUint32(err)) {
716         LOGE("StorageManagerStub::HandleGetVolumeById call GetVolumeById failed");
717         return E_WRITE_REPLY_ERR;
718     }
719     return E_OK;
720 }
721 
HandleSetVolDesc(MessageParcel & data,MessageParcel & reply)722 int32_t StorageManagerStub::HandleSetVolDesc(MessageParcel &data, MessageParcel &reply)
723 {
724     if (!CheckClientPermission(PERMISSION_MOUNT_MANAGER)) {
725         return E_PERMISSION_DENIED;
726     }
727     std::string fsUuid = data.ReadString();
728     std::string desc = data.ReadString();
729     int err = SetVolumeDescription(fsUuid, desc);
730     if (!reply.WriteUint32(err)) {
731         LOGE("StorageManagerStub::HandleSetVolDesc call SetVolumeDescription failed");
732         return E_WRITE_REPLY_ERR;
733     }
734     return E_OK;
735 }
736 
HandleFormat(MessageParcel & data,MessageParcel & reply)737 int32_t StorageManagerStub::HandleFormat(MessageParcel &data, MessageParcel &reply)
738 {
739     if (!CheckClientPermission(PERMISSION_FORMAT_MANAGER)) {
740         return E_PERMISSION_DENIED;
741     }
742     std::string volId = data.ReadString();
743     std::string fsType = data.ReadString();
744     int err = Format(volId, fsType);
745     if (!reply.WriteUint32(err)) {
746         LOGE("StorageManagerStub::HandleFormat call Format failed");
747         return E_WRITE_REPLY_ERR;
748     }
749     return E_OK;
750 }
751 
HandleGetDiskById(MessageParcel & data,MessageParcel & reply)752 int32_t StorageManagerStub::HandleGetDiskById(MessageParcel &data, MessageParcel &reply)
753 {
754     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
755         return E_PERMISSION_DENIED;
756     }
757     std::string volId = data.ReadString();
758     Disk disk;
759     int err = GetDiskById(volId, disk);
760     if (!disk.Marshalling(reply)) {
761         return E_WRITE_REPLY_ERR;
762     }
763     if (!reply.WriteUint32(err)) {
764         LOGE("StorageManagerStub::HandleGetDiskById call GetDiskById failed");
765         return E_WRITE_REPLY_ERR;
766     }
767     return E_OK;
768 }
769 
HandleGenerateUserKeys(MessageParcel & data,MessageParcel & reply)770 int32_t StorageManagerStub::HandleGenerateUserKeys(MessageParcel &data, MessageParcel &reply)
771 {
772     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
773         return E_PERMISSION_DENIED;
774     }
775     uint32_t userId = data.ReadUint32();
776     uint32_t flags = data.ReadUint32();
777     int32_t err = GenerateUserKeys(userId, flags);
778     if (!reply.WriteInt32(err)) {
779         LOGE("Write reply error code failed");
780         return E_WRITE_REPLY_ERR;
781     }
782 
783     return E_OK;
784 }
785 
HandleDeleteUserKeys(MessageParcel & data,MessageParcel & reply)786 int32_t StorageManagerStub::HandleDeleteUserKeys(MessageParcel &data, MessageParcel &reply)
787 {
788     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
789         return E_PERMISSION_DENIED;
790     }
791     uint32_t userId = data.ReadUint32();
792     int32_t err = DeleteUserKeys(userId);
793     if (!reply.WriteInt32(err)) {
794         LOGE("Write reply error code failed");
795         return E_WRITE_REPLY_ERR;
796     }
797 
798     return E_OK;
799 }
800 
HandleUpdateUserAuth(MessageParcel & data,MessageParcel & reply)801 int32_t StorageManagerStub::HandleUpdateUserAuth(MessageParcel &data, MessageParcel &reply)
802 {
803     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
804         return E_PERMISSION_DENIED;
805     }
806     uint32_t userId = data.ReadUint32();
807     uint64_t secureUid = data.ReadUint64();
808 
809     std::vector<uint8_t> token;
810     std::vector<uint8_t> oldSecret;
811     std::vector<uint8_t> newSecret;
812     data.ReadUInt8Vector(&token);
813     data.ReadUInt8Vector(&oldSecret);
814     data.ReadUInt8Vector(&newSecret);
815 
816     int32_t err = UpdateUserAuth(userId, secureUid, token, oldSecret, newSecret);
817     if (!reply.WriteInt32(err)) {
818         LOGE("Write reply error code failed");
819         return E_WRITE_REPLY_ERR;
820     }
821     return E_OK;
822 }
823 
HandleActiveUserKey(MessageParcel & data,MessageParcel & reply)824 int32_t StorageManagerStub::HandleActiveUserKey(MessageParcel &data, MessageParcel &reply)
825 {
826     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
827         return E_PERMISSION_DENIED;
828     }
829     uint32_t userId = data.ReadUint32();
830 
831     std::vector<uint8_t> token;
832     std::vector<uint8_t> secret;
833     data.ReadUInt8Vector(&token);
834     data.ReadUInt8Vector(&secret);
835 
836     int32_t err = ActiveUserKey(userId, token, secret);
837     if (!reply.WriteInt32(err)) {
838         LOGE("Write reply error code failed");
839         return E_WRITE_REPLY_ERR;
840     }
841     return E_OK;
842 }
843 
HandleInactiveUserKey(MessageParcel & data,MessageParcel & reply)844 int32_t StorageManagerStub::HandleInactiveUserKey(MessageParcel &data, MessageParcel &reply)
845 {
846     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
847         return E_PERMISSION_DENIED;
848     }
849     uint32_t userId = data.ReadUint32();
850     int32_t err = InactiveUserKey(userId);
851     if (!reply.WriteInt32(err)) {
852         LOGE("Write reply error code failed");
853         return E_WRITE_REPLY_ERR;
854     }
855     return E_OK;
856 }
857 
HandleLockUserScreen(MessageParcel & data,MessageParcel & reply)858 int32_t StorageManagerStub::HandleLockUserScreen(MessageParcel &data, MessageParcel &reply)
859 {
860     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
861         return E_PERMISSION_DENIED;
862     }
863     uint32_t userId = data.ReadUint32();
864     int32_t err = LockUserScreen(userId);
865     if (!reply.WriteInt32(err)) {
866         LOGE("Write reply error code failed");
867         return E_WRITE_REPLY_ERR;
868     }
869 
870     return E_OK;
871 }
872 
HandleGetFileEncryptStatus(MessageParcel & data,MessageParcel & reply)873 int32_t StorageManagerStub::HandleGetFileEncryptStatus(MessageParcel &data, MessageParcel &reply)
874 {
875     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
876         return E_PERMISSION_DENIED;
877     }
878     bool isEncrypted = true;
879     uint32_t userId = data.ReadUint32();
880     bool needCheckDirMount = data.ReadBool();
881     int32_t err = GetFileEncryptStatus(userId, isEncrypted, needCheckDirMount);
882     if (!reply.WriteInt32(err)) {
883         LOGE("Write reply error code failed");
884         return E_WRITE_REPLY_ERR;
885     }
886     if (!reply.WriteBool(isEncrypted)) {
887         LOGE("Write reply isEncrypted failed");
888         return E_WRITE_REPLY_ERR;
889     }
890     return E_OK;
891 }
892 
HandleUnlockUserScreen(MessageParcel & data,MessageParcel & reply)893 int32_t StorageManagerStub::HandleUnlockUserScreen(MessageParcel &data, MessageParcel &reply)
894 {
895     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
896         return E_PERMISSION_DENIED;
897     }
898     uint32_t userId = data.ReadUint32();
899 
900     std::vector<uint8_t> token;
901     std::vector<uint8_t> secret;
902     data.ReadUInt8Vector(&token);
903     data.ReadUInt8Vector(&secret);
904 
905     int32_t err = UnlockUserScreen(userId, token, secret);
906     if (!reply.WriteInt32(err)) {
907         LOGE("Write reply error code failed");
908         return E_WRITE_REPLY_ERR;
909     }
910     return E_OK;
911 }
912 
HandleGetLockScreenStatus(MessageParcel & data,MessageParcel & reply)913 int32_t StorageManagerStub::HandleGetLockScreenStatus(MessageParcel &data, MessageParcel &reply)
914 {
915     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER)) {
916         return E_PERMISSION_DENIED;
917     }
918     uint32_t userId = data.ReadUint32();
919     bool lockScreenStatus = false;
920     int32_t err = GetLockScreenStatus(userId, lockScreenStatus);
921     if (!reply.WriteBool(lockScreenStatus)) {
922         LOGE("Write reply lockScreenStatus failed");
923         return E_WRITE_REPLY_ERR;
924     }
925     if (!reply.WriteInt32(err)) {
926         LOGE("Write reply error code failed");
927         return E_WRITE_REPLY_ERR;
928     }
929     return E_OK;
930 }
931 
HandleGenerateAppkey(MessageParcel & data,MessageParcel & reply)932 int32_t StorageManagerStub::HandleGenerateAppkey(MessageParcel &data, MessageParcel &reply)
933 {
934     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
935         return E_PERMISSION_DENIED;
936     }
937     uint32_t hashId = data.ReadUint32();
938     uint32_t userId = data.ReadUint32();
939     std::string keyId;
940     int32_t err = GenerateAppkey(hashId, userId, keyId);
941     if (!reply.WriteString(keyId)) {
942         LOGE("Write reply lockScreenStatus failed");
943         return E_WRITE_REPLY_ERR;
944     }
945     if (!reply.WriteInt32(err)) {
946         LOGE("Write reply error code failed");
947         return E_WRITE_REPLY_ERR;
948     }
949     return E_OK;
950 }
951 
HandleDeleteAppkey(MessageParcel & data,MessageParcel & reply)952 int32_t StorageManagerStub::HandleDeleteAppkey(MessageParcel &data, MessageParcel &reply)
953 {
954     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
955         return E_PERMISSION_DENIED;
956     }
957     std::string keyId = data.ReadString();
958     int32_t err = DeleteAppkey(keyId);
959     if (!reply.WriteInt32(err)) {
960         LOGE("Write reply error code failed");
961         return E_WRITE_REPLY_ERR;
962     }
963     return E_OK;
964 }
965 
HandleUpdateKeyContext(MessageParcel & data,MessageParcel & reply)966 int32_t StorageManagerStub::HandleUpdateKeyContext(MessageParcel &data, MessageParcel &reply)
967 {
968     if (!CheckClientPermissionForCrypt(PERMISSION_STORAGE_MANAGER_CRYPT)) {
969         return E_PERMISSION_DENIED;
970     }
971     uint32_t userId = data.ReadUint32();
972     int32_t err = UpdateKeyContext(userId);
973     if (!reply.WriteInt32(err)) {
974         LOGE("Write reply error code failed");
975         return E_WRITE_REPLY_ERR;
976     }
977     return E_OK;
978 }
979 
HandleCreateShareFile(MessageParcel & data,MessageParcel & reply)980 int32_t StorageManagerStub::HandleCreateShareFile(MessageParcel &data, MessageParcel &reply)
981 {
982     if (!CheckClientPermissionForShareFile()) {
983         return E_PERMISSION_DENIED;
984     }
985 
986     std::vector<std::string> uriList;
987     if (!data.ReadStringVector(&uriList)) {
988         return E_WRITE_REPLY_ERR;
989     }
990     uint32_t tokenId = data.ReadUint32();
991     uint32_t flag = data.ReadUint32();
992     std::vector<int32_t> retList = CreateShareFile(uriList, tokenId, flag);
993     if (!reply.WriteInt32Vector(retList)) {
994         return E_WRITE_REPLY_ERR;
995     }
996     return E_OK;
997 }
998 
HandleDeleteShareFile(MessageParcel & data,MessageParcel & reply)999 int32_t StorageManagerStub::HandleDeleteShareFile(MessageParcel &data, MessageParcel &reply)
1000 {
1001     if (!CheckClientPermissionForShareFile()) {
1002         return E_PERMISSION_DENIED;
1003     }
1004 
1005     uint32_t tokenId = data.ReadUint32();
1006     std::vector<std::string> uriList;
1007     if (!data.ReadStringVector(&uriList)) {
1008         return E_WRITE_REPLY_ERR;
1009     }
1010 
1011     int err = DeleteShareFile(tokenId, uriList);
1012     if (!reply.WriteInt32(err)) {
1013         return E_WRITE_REPLY_ERR;
1014     }
1015     return E_OK;
1016 }
1017 
HandleSetBundleQuota(MessageParcel & data,MessageParcel & reply)1018 int32_t StorageManagerStub::HandleSetBundleQuota(MessageParcel &data, MessageParcel &reply)
1019 {
1020     if (!CheckClientPermission(PERMISSION_STORAGE_MANAGER)) {
1021         return E_PERMISSION_DENIED;
1022     }
1023 
1024     std::string bundleName = data.ReadString();
1025     int32_t uid = data.ReadInt32();
1026     std::string bundleDataDirPath = data.ReadString();
1027     int32_t limitSizeMb = data.ReadInt32();
1028     int err = SetBundleQuota(bundleName, uid, bundleDataDirPath, limitSizeMb);
1029     if (!reply.WriteInt32(err)) {
1030         return E_WRITE_REPLY_ERR;
1031     }
1032     return E_OK;
1033 }
1034 
HandleGetBundleStatsForIncrease(MessageParcel & data,MessageParcel & reply)1035 int32_t StorageManagerStub::HandleGetBundleStatsForIncrease(MessageParcel &data, MessageParcel &reply)
1036 {
1037     if (IPCSkeleton::GetCallingUid() != BACKUP_SA_UID) {
1038         LOGE("StorageManager permissionCheck error, calling uid is invalid, need backup_sa uid.");
1039         return E_PERMISSION_DENIED;
1040     }
1041 
1042     uint32_t userId = data.ReadUint32();
1043     std::vector<std::string> bundleNames;
1044     if (!data.ReadStringVector(&bundleNames)) {
1045         return E_WRITE_REPLY_ERR;
1046     }
1047     std::vector<int64_t> incrementalBackTimes;
1048     if (!data.ReadInt64Vector(&incrementalBackTimes)) {
1049         return E_WRITE_REPLY_ERR;
1050     }
1051 
1052     std::vector<int64_t> pkgFileSizes;
1053     std::vector<int64_t> incPkgFileSizes;
1054     int32_t err = GetBundleStatsForIncrease(userId, bundleNames, incrementalBackTimes, pkgFileSizes, incPkgFileSizes);
1055     if (!reply.WriteUint32(err)) {
1056         return E_WRITE_REPLY_ERR;
1057     }
1058     if (!reply.WriteInt64Vector(pkgFileSizes)) {
1059         LOGE("StorageManagerStub::HandleGetBundleStatsForIncrease call GetBundleStatsForIncrease failed");
1060         return  E_WRITE_REPLY_ERR;
1061     }
1062     if (!reply.WriteInt64Vector(incPkgFileSizes)) {
1063         LOGE("StorageManagerStub::HandleGetBundleStatsForIncrease call GetBundleStatsForIncrease failed");
1064         return  E_WRITE_REPLY_ERR;
1065     }
1066     return E_OK;
1067 }
1068 
1069 
HandleGetUserStorageStatsByType(MessageParcel & data,MessageParcel & reply)1070 int32_t StorageManagerStub::HandleGetUserStorageStatsByType(MessageParcel &data, MessageParcel &reply)
1071 {
1072     if (IPCSkeleton::GetCallingUid() != BACKUP_SA_UID) {
1073         LOGE("StorageManager permissionCheck error, calling uid is invalid, need backup_sa uid.");
1074         return E_PERMISSION_DENIED;
1075     }
1076 
1077     int32_t userId = data.ReadInt32();
1078     std::string type = data.ReadString();
1079     StorageStats storageStats;
1080     int32_t err = GetUserStorageStatsByType(userId, storageStats, type);
1081     if (!reply.WriteInt32(err)) {
1082         return E_WRITE_REPLY_ERR;
1083     }
1084     if (!storageStats.Marshalling(reply)) {
1085         return  E_WRITE_REPLY_ERR;
1086     }
1087     return E_OK;
1088 }
1089 
HandleUpdateMemoryPara(MessageParcel & data,MessageParcel & reply)1090 int32_t StorageManagerStub::HandleUpdateMemoryPara(MessageParcel &data, MessageParcel &reply)
1091 {
1092     if (IPCSkeleton::GetCallingUid() != BACKUP_SA_UID) {
1093         LOGE("StorageManager permissionCheck error, calling uid is invalid, need backup_sa uid.");
1094         return E_PERMISSION_DENIED;
1095     }
1096 
1097     int32_t size = data.ReadInt32();
1098     int32_t oldSize = 0;
1099     int err = UpdateMemoryPara(size, oldSize);
1100     if (!reply.WriteInt32(err)) {
1101         return E_WRITE_REPLY_ERR;
1102     }
1103     if (!reply.WriteInt32(oldSize)) {
1104         LOGE("StorageManagerStub::HandleUpdateMemoryPara call UpdateMemoryPara failed");
1105         return E_WRITE_REPLY_ERR;
1106     }
1107     return E_OK;
1108 }
1109 
HandleMountDfsDocs(MessageParcel & data,MessageParcel & reply)1110 int32_t StorageManagerStub::HandleMountDfsDocs(MessageParcel &data, MessageParcel &reply)
1111 {
1112     // Only for dfs create device dir and bind mount from DFS Docs.
1113     if (IPCSkeleton::GetCallingUid() != DFS_UID) {
1114         LOGE("HandleMountDfsDocs permissionCheck error, calling uid now is %{public}d, should be DFS_UID: %{public}d",
1115             IPCSkeleton::GetCallingUid(), DFS_UID);
1116         return E_PERMISSION_DENIED;
1117     }
1118 
1119     int32_t userId = data.ReadInt32();
1120     std::string relativePath = data.ReadString();
1121     std::string networkId = data.ReadString();
1122     std::string deviceId = data.ReadString();
1123 
1124     int32_t err = MountDfsDocs(userId, relativePath, networkId, deviceId);
1125     if (!reply.WriteInt32(err)) {
1126         return E_WRITE_REPLY_ERR;
1127     }
1128     return E_OK;
1129 }
1130 
HandleUMountDfsDocs(MessageParcel & data,MessageParcel & reply)1131 int32_t StorageManagerStub::HandleUMountDfsDocs(MessageParcel &data, MessageParcel &reply)
1132 {
1133     // Only for dfs create device dir and bind mount from DFS Docs.
1134     if (IPCSkeleton::GetCallingUid() != DFS_UID) {
1135         LOGE("HandleUMountDfsDocs permissionCheck error, calling uid now is %{public}d, should be DFS_UID: %{public}d",
1136              IPCSkeleton::GetCallingUid(), DFS_UID);
1137         return E_PERMISSION_DENIED;
1138     }
1139 
1140     int32_t userId = data.ReadInt32();
1141     std::string relativePath = data.ReadString();
1142     std::string networkId = data.ReadString();
1143     std::string deviceId = data.ReadString();
1144     int32_t err = UMountDfsDocs(userId, relativePath, networkId, deviceId);
1145     if (!reply.WriteInt32(err)) {
1146         return E_WRITE_REPLY_ERR;
1147     }
1148     return E_OK;
1149 }
1150 } // StorageManager
1151 } // OHOS
1152