1 /*
2 * Copyright (c) 2021 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_service_errno.h"
20 #include "storage_service_log.h"
21
22 namespace OHOS {
23 namespace StorageManager {
GetClientUid(int & uid)24 static bool GetClientUid(int &uid)
25 {
26 uid = IPCSkeleton::GetCallingUid();
27 return true;
28 }
29
CheckClientPermission(const std::string & permissionStr)30 bool CheckClientPermission(const std::string& permissionStr)
31 {
32 int uid = -1;
33 if (!GetClientUid(uid)) {
34 LOGE("GetClientUid: fail");
35 }
36 LOGI("uid: %{public}d", uid);
37 if (uid == UID_ACCOUNTMGR || uid == UID_SYSTEM || uid == UID_ROOT || uid == UID_FMS) {
38 LOGI("StorageManager permissionCheck pass!");
39 return true;
40 }
41 Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
42 int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller,
43 permissionStr);
44 if (res == Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
45 LOGI("Have media permission");
46 return true;
47 }
48 return false;
49 }
50
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)51 int32_t StorageManagerStub::OnRemoteRequest(uint32_t code,
52 MessageParcel &data, MessageParcel &reply, MessageOption &option)
53 {
54 auto remoteDescriptor = data.ReadInterfaceToken();
55 if (GetDescriptor() != remoteDescriptor) {
56 return E_PERMISSION_DENIED;
57 }
58 std::string permission = "ohos.permission.READ_MEDIA";
59 if (!CheckClientPermission(permission)) {
60 LOGE("StorageManager permissionCheck error!");
61 return E_PERMISSION_DENIED;
62 }
63 int err = 0;
64 switch (code) {
65 case PREPARE_ADD_USER:
66 HandlePrepareAddUser(data, reply);
67 break;
68 case REMOVE_USER:
69 HandleRemoveUser(data, reply);
70 break;
71 case PREPARE_START_USER:
72 HandlePrepareStartUser(data, reply);
73 break;
74 case STOP_USER:
75 HandleStopUser(data, reply);
76 break;
77 case GET_TOTAL:
78 HandleGetTotal(data, reply);
79 break;
80 case GET_FREE:
81 HandleGetFree(data, reply);
82 break;
83 case GET_BUNDLE_STATUS:
84 HandleGetBundleStatus(data, reply);
85 break;
86 case NOTIFY_VOLUME_CREATED:
87 HandleNotifyVolumeCreated(data, reply);
88 break;
89 case NOTIFY_VOLUME_MOUNTED:
90 HandleNotifyVolumeMounted(data, reply);
91 break;
92 case NOTIFY_VOLUME_DESTROYED:
93 HandleNotifyVolumeDestroyed(data, reply);
94 break;
95 case MOUNT:
96 HandleMount(data, reply);
97 break;
98 case UNMOUNT:
99 HandleUnmount(data, reply);
100 break;
101 case GET_ALL_VOLUMES:
102 HandleGetAllVolumes(data, reply);
103 break;
104 case NOTIFY_DISK_CREATED:
105 HandleNotifyDiskCreated(data, reply);
106 break;
107 case NOTIFY_DISK_DESTROYED:
108 HandleNotifyDiskDestroyed(data, reply);
109 break;
110 case PARTITION:
111 HandlePartition(data, reply);
112 break;
113 case GET_ALL_DISKS:
114 HandleGetAllDisks(data, reply);
115 break;
116 case CREATE_USER_KEYS:
117 HandleGenerateUserKeys(data, reply);
118 break;
119 case DELETE_USER_KEYS:
120 HandleDeleteUserKeys(data, reply);
121 break;
122 case UPDATE_USER_AUTH:
123 HandleUpdateUserAuth(data, reply);
124 break;
125 case ACTIVE_USER_KEY:
126 HandleActiveUserKey(data, reply);
127 break;
128 case INACTIVE_USER_KEY:
129 HandleInactiveUserKey(data, reply);
130 break;
131 case UPDATE_KEY_CONTEXT:
132 HandleUpdateKeyContext(data, reply);
133 break;
134 default: {
135 LOGI("use IPCObjectStub default OnRemoteRequest");
136 err = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
137 break;
138 }
139 }
140 return err;
141 }
142
HandlePrepareAddUser(MessageParcel & data,MessageParcel & reply)143 int32_t StorageManagerStub::HandlePrepareAddUser(MessageParcel &data, MessageParcel &reply)
144 {
145 int32_t userId = data.ReadInt32();
146 uint32_t flags = data.ReadUint32();
147 LOGI("StorageManagerStub::HandlePrepareAddUser, userId:%{public}d", userId);
148 int err = PrepareAddUser(userId, flags);
149 if (!reply.WriteUint32(err)) {
150 LOGE("StorageManagerStub::HandlePrepareAddUser call PrepareAddUser failed");
151 return E_IPC_ERROR;
152 }
153 return E_OK;
154 }
155
HandleRemoveUser(MessageParcel & data,MessageParcel & reply)156 int32_t StorageManagerStub::HandleRemoveUser(MessageParcel &data, MessageParcel &reply)
157 {
158 int32_t userId = data.ReadInt32();
159 uint32_t flags = data.ReadUint32();
160 LOGI("StorageManagerStub::HandleRemoveUser, userId:%{public}d", userId);
161 int err = RemoveUser(userId, flags);
162 if (!reply.WriteUint32(err)) {
163 LOGE("StorageManagerStub::HandleRemoveUser call RemoveUser failed");
164 return E_IPC_ERROR;
165 }
166 return E_OK;
167 }
168
HandlePrepareStartUser(MessageParcel & data,MessageParcel & reply)169 int32_t StorageManagerStub::HandlePrepareStartUser(MessageParcel &data, MessageParcel &reply)
170 {
171 int32_t userId = data.ReadInt32();
172 LOGI("StorageManagerStub::HandlePrepareStartUser, userId:%{public}d", userId);
173 int err = PrepareStartUser(userId);
174 if (!reply.WriteUint32(err)) {
175 LOGE("StorageManagerStub::HandlePrepareStartUser call PrepareStartUser failed");
176 return E_IPC_ERROR;
177 }
178 return E_OK;
179 }
180
HandleStopUser(MessageParcel & data,MessageParcel & reply)181 int32_t StorageManagerStub::HandleStopUser(MessageParcel &data, MessageParcel &reply)
182 {
183 int32_t userId = data.ReadInt32();
184 LOGI("StorageManagerStub::HandleStopUser, userId:%{public}d", userId);
185 int err = StopUser(userId);
186 if (!reply.WriteUint32(err)) {
187 LOGE("StorageManagerStub::HandleStopUser call StopUser failed");
188 return E_IPC_ERROR;
189 }
190 return E_OK;
191 }
192
HandleGetTotal(MessageParcel & data,MessageParcel & reply)193 int32_t StorageManagerStub::HandleGetTotal(MessageParcel &data, MessageParcel &reply)
194 {
195 LOGE("StorageManagerStub::HandleGetTotal Begin.");
196 std::string volumeId = data.ReadString();
197 int64_t totalSize = GetTotalSizeOfVolume(volumeId);
198 if (!reply.WriteInt64(totalSize)) {
199 LOGE("StorageManagerStub::HandleGetTotal call OnUserDelete failed");
200 return E_IPC_ERROR;
201 }
202 return E_OK;
203 }
204
HandleGetFree(MessageParcel & data,MessageParcel & reply)205 int32_t StorageManagerStub::HandleGetFree(MessageParcel &data, MessageParcel &reply)
206 {
207 std::string volumeId = data.ReadString();
208 int64_t freeSize = GetFreeSizeOfVolume(volumeId);
209 if (!reply.WriteInt64(freeSize)) {
210 LOGE("StorageManagerStub::HandleGetFree call OnUserDelete failed");
211 return E_IPC_ERROR;
212 }
213 return E_OK;
214 }
215
HandleGetBundleStatus(MessageParcel & data,MessageParcel & reply)216 int32_t StorageManagerStub::HandleGetBundleStatus(MessageParcel &data, MessageParcel &reply)
217 {
218 std::string pkgName = data.ReadString();
219 std::vector<int64_t> bundleStats = GetBundleStats(pkgName);
220 if (!reply.WriteInt64Vector(bundleStats)) {
221 return E_IPC_ERROR;
222 }
223 return E_OK;
224 }
225
HandleGetAllVolumes(MessageParcel & data,MessageParcel & reply)226 int32_t StorageManagerStub::HandleGetAllVolumes(MessageParcel &data, MessageParcel &reply)
227 {
228 LOGE("StorageManagerStub::HandleGetAllVolumes Begin.");
229 std::vector<VolumeExternal> ve = GetAllVolumes();
230 uint size = ve.size();
231 if (size == 0) {
232 LOGE("StorageManagerStub::No volume.");
233 if (!reply.WriteUint32(0)) {
234 return E_IPC_ERROR;
235 }
236 return E_OK;
237 }
238 if (!reply.WriteUint32(ve.size())) {
239 return E_IPC_ERROR;
240 }
241 for (int i = 0; i < size; i++) {
242 if (!ve[i].Marshalling(reply)) {
243 return E_IPC_ERROR;
244 }
245 }
246 return E_OK;
247 }
248
HandleNotifyVolumeCreated(MessageParcel & data,MessageParcel & reply)249 int32_t StorageManagerStub::HandleNotifyVolumeCreated(MessageParcel &data, MessageParcel &reply)
250 {
251 std::unique_ptr<VolumeCore> vc = VolumeCore::Unmarshalling(data);
252 NotifyVolumeCreated(*vc);
253 LOGI("StorageManagerStub::HandleNotifyVolumeCreated");
254 return E_OK;
255 }
256
HandleNotifyVolumeMounted(MessageParcel & data,MessageParcel & reply)257 int32_t StorageManagerStub::HandleNotifyVolumeMounted(MessageParcel &data, MessageParcel &reply)
258 {
259 std::string volumeId = data.ReadString();
260 int32_t fsType = data.ReadInt32();
261 std::string fsUuid = data.ReadString();
262 std::string path = data.ReadString();
263 std::string description = data.ReadString();
264 NotifyVolumeMounted(volumeId, fsType, fsUuid, path, description);
265 LOGI("StorageManagerStub::HandleNotifyVolumeMounted");
266 return E_OK;
267 }
268
HandleNotifyVolumeDestroyed(MessageParcel & data,MessageParcel & reply)269 int32_t StorageManagerStub::HandleNotifyVolumeDestroyed(MessageParcel &data, MessageParcel &reply)
270 {
271 std::string volumeId = data.ReadString();
272 NotifyVolumeDestroyed(volumeId);
273 LOGI("StorageManagerStub::HandleNotifyVolumeDestroyed");
274 return E_OK;
275 }
276
HandleMount(MessageParcel & data,MessageParcel & reply)277 int32_t StorageManagerStub::HandleMount(MessageParcel &data, MessageParcel &reply)
278 {
279 LOGE("StorageManagerStub::HandleMount Begin.");
280 std::string volumeId = data.ReadString();
281 int err = Mount(volumeId);
282 if (!reply.WriteUint32(err)) {
283 LOGE("StorageManagerStub::HandleMount call Mount failed");
284 return E_IPC_ERROR;
285 }
286 return E_OK;
287 }
288
HandleUnmount(MessageParcel & data,MessageParcel & reply)289 int32_t StorageManagerStub::HandleUnmount(MessageParcel &data, MessageParcel &reply)
290 {
291 LOGE("StorageManagerStub::HandleUnmount Begin.");
292 std::string volumeId = data.ReadString();
293 int err = Unmount(volumeId);
294 if (!reply.WriteUint32(err)) {
295 LOGE("StorageManagerStub::HandleUnmount call Mount failed");
296 return E_IPC_ERROR;
297 }
298 return E_OK;
299 }
300
HandleNotifyDiskCreated(MessageParcel & data,MessageParcel & reply)301 int32_t StorageManagerStub::HandleNotifyDiskCreated(MessageParcel &data, MessageParcel &reply)
302 {
303 auto disk = Disk::Unmarshalling(data);
304 NotifyDiskCreated(*disk);
305 return E_OK;
306 }
307
HandleNotifyDiskDestroyed(MessageParcel & data,MessageParcel & reply)308 int32_t StorageManagerStub::HandleNotifyDiskDestroyed(MessageParcel &data, MessageParcel &reply)
309 {
310 std::string diskId = data.ReadString();
311 NotifyDiskDestroyed(diskId);
312 return E_OK;
313 }
314
HandlePartition(MessageParcel & data,MessageParcel & reply)315 int32_t StorageManagerStub::HandlePartition(MessageParcel &data, MessageParcel &reply)
316 {
317 std::string diskId = data.ReadString();
318 int32_t type = data.ReadInt32();
319 int err = Partition(diskId, type);
320 if (!reply.WriteUint32(err)) {
321 LOGE("StorageManagerStub::HandlePartition call Partition failed");
322 return E_IPC_ERROR;
323 }
324 return E_OK;
325 }
326
HandleGetAllDisks(MessageParcel & data,MessageParcel & reply)327 int32_t StorageManagerStub::HandleGetAllDisks(MessageParcel &data, MessageParcel &reply)
328 {
329 LOGE("StorageManagerStub::HandleGetAllDisk Begin.");
330 std::vector<Disk> disks = GetAllDisks();
331 uint size = disks.size();
332 if (size == 0) {
333 LOGE("StorageManagerStub::No Disk.");
334 if (!reply.WriteUint32(0)) {
335 return E_IPC_ERROR;
336 }
337 return E_OK;
338 }
339 if (!reply.WriteUint32(disks.size())) {
340 return E_IPC_ERROR;
341 }
342 for (int i = 0; i < size; i++) {
343 if (!disks[i].Marshalling(reply)) {
344 return E_IPC_ERROR;
345 }
346 }
347 return E_OK;
348 }
349
HandleGenerateUserKeys(MessageParcel & data,MessageParcel & reply)350 int32_t StorageManagerStub::HandleGenerateUserKeys(MessageParcel &data, MessageParcel &reply)
351 {
352 uint32_t userId = data.ReadUint32();
353 uint32_t flags = data.ReadUint32();
354 int32_t err = GenerateUserKeys(userId, flags);
355 if (!reply.WriteInt32(err)) {
356 LOGE("Write reply error code failed");
357 return E_IPC_ERROR;
358 }
359
360 return E_OK;
361 }
362
HandleDeleteUserKeys(MessageParcel & data,MessageParcel & reply)363 int32_t StorageManagerStub::HandleDeleteUserKeys(MessageParcel &data, MessageParcel &reply)
364 {
365 uint32_t userId = data.ReadUint32();
366 int32_t err = DeleteUserKeys(userId);
367 if (!reply.WriteInt32(err)) {
368 LOGE("Write reply error code failed");
369 return E_IPC_ERROR;
370 }
371
372 return E_OK;
373 }
374
HandleUpdateUserAuth(MessageParcel & data,MessageParcel & reply)375 int32_t StorageManagerStub::HandleUpdateUserAuth(MessageParcel &data, MessageParcel &reply)
376 {
377 uint32_t userId = data.ReadUint32();
378 std::string auth = data.ReadString();
379 std::string compSecret = data.ReadString();
380 int32_t err = UpdateUserAuth(userId, auth, compSecret);
381 if (!reply.WriteInt32(err)) {
382 LOGE("Write reply error code failed");
383 return E_IPC_ERROR;
384 }
385
386 return E_OK;
387 }
388
HandleActiveUserKey(MessageParcel & data,MessageParcel & reply)389 int32_t StorageManagerStub::HandleActiveUserKey(MessageParcel &data, MessageParcel &reply)
390 {
391 uint32_t userId = data.ReadUint32();
392 std::string auth = data.ReadString();
393 std::string compSecret = data.ReadString();
394 int32_t err = ActiveUserKey(userId, auth, compSecret);
395 if (!reply.WriteInt32(err)) {
396 LOGE("Write reply error code failed");
397 return E_IPC_ERROR;
398 }
399
400 return E_OK;
401 }
402
HandleInactiveUserKey(MessageParcel & data,MessageParcel & reply)403 int32_t StorageManagerStub::HandleInactiveUserKey(MessageParcel &data, MessageParcel &reply)
404 {
405 uint32_t userId = data.ReadUint32();
406 int32_t err = InactiveUserKey(userId);
407 if (!reply.WriteInt32(err)) {
408 LOGE("Write reply error code failed");
409 return E_IPC_ERROR;
410 }
411
412 return E_OK;
413 }
414
HandleUpdateKeyContext(MessageParcel & data,MessageParcel & reply)415 int32_t StorageManagerStub::HandleUpdateKeyContext(MessageParcel &data, MessageParcel &reply)
416 {
417 uint32_t userId = data.ReadUint32();
418 int32_t err = UpdateKeyContext(userId);
419 if (!reply.WriteInt32(err)) {
420 LOGE("Write reply error code failed");
421 return E_IPC_ERROR;
422 }
423
424 return E_OK;
425 }
426 } // StorageManager
427 } // OHOS
428