1 /*
2  * Copyright (c) 2021-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 
16 #include "system_ability_manager_stub.h"
17 
18 #include <unistd.h>
19 #include <cinttypes>
20 
21 #include "accesstoken_kit.h"
22 #include "datetime_ex.h"
23 #include "errors.h"
24 #include "hitrace_meter.h"
25 #include "ipc_skeleton.h"
26 #include "ipc_types.h"
27 #include "memory_guard.h"
28 #include "sam_log.h"
29 #include "string_ex.h"
30 #include "hisysevent_adapter.h"
31 #include "system_ability_manager.h"
32 #include "system_ability_manager_util.h"
33 #include "system_ability_on_demand_event.h"
34 #include "tools.h"
35 #include "samgr_xcollie.h"
36 
37 #ifdef WITH_SELINUX
38 #include "service_checker.h"
39 #define HILOG_SE_DEBUG(type, fmt, ...) HILOG_IMPL((type), LOG_DEBUG, LOG_DOMAIN, "SA_SELINUX", fmt, __VA_ARGS__)
40 #endif
41 
42 namespace {
43 #ifdef WITH_SELINUX
44     std::unique_ptr<ServiceChecker> selinuxChecker_ = std::make_unique<ServiceChecker>(false);
45 #endif
46 
CheckGetSAPermission(const int32_t said)47     bool CheckGetSAPermission(const int32_t said)
48     {
49 #ifdef WITH_SELINUX
50         int64_t begin = OHOS::GetTickCount();
51         auto callingSid = OHOS::IPCSkeleton::GetCallingSid();
52         auto ret = selinuxChecker_->GetServiceCheck(callingSid, std::to_string(said)) == 0;
53         HILOG_SE_DEBUG(LOG_CORE, "GetServiceCheck callingSid:%{public}s,SA:%{public}d,ret:%{public}s,spend:%{public}"
54             PRId64 "ms", callingSid.c_str(), said, ret == true ? "suc" : "fail", OHOS::GetTickCount() - begin);
55         return  ret;
56 #else
57         return true; // if not support selinux, not check selinux permission
58 #endif
59     }
60 
CheckAddOrRemovePermission(const int32_t said)61     bool CheckAddOrRemovePermission(const int32_t said)
62     {
63 #ifdef WITH_SELINUX
64         int64_t begin = OHOS::GetTickCount();
65         auto callingSid = OHOS::IPCSkeleton::GetCallingSid();
66         auto ret = selinuxChecker_->AddServiceCheck(callingSid, std::to_string(said)) == 0;
67         HILOG_SE_DEBUG(LOG_CORE, "AddServiceCheck callingSid:%{public}s,SA:%{public}d,ret:%{public}s,spend:%{public}"
68             PRId64 "ms", callingSid.c_str(), said, ret == true ? "suc" : "fail", OHOS::GetTickCount() - begin);
69         return ret;
70 #else
71         return true; // if not support selinux, not check selinux permission
72 #endif
73     }
74 
CheckGetRemoteSAPermission(const int32_t said)75     bool CheckGetRemoteSAPermission(const int32_t said)
76     {
77 #ifdef WITH_SELINUX
78         int64_t begin = OHOS::GetTickCount();
79         auto callingSid = OHOS::IPCSkeleton::GetCallingSid();
80         auto ret = selinuxChecker_->GetRemoteServiceCheck(callingSid, std::to_string(said)) == 0;
81         HILOG_SE_DEBUG(LOG_CORE, "GetRemoteServiceCheck callingSid:%{public}s,SA:%{public}d,"
82             "ret:%{public}s,spend:%{public}" PRId64 "ms", callingSid.c_str(), said,
83             ret == true ? "suc" : "fail", OHOS::GetTickCount() - begin);
84         return ret;
85 #else
86         return true; // if not support selinux, not check selinux permission
87 #endif
88     }
89 
CheckListSAPermission()90     bool CheckListSAPermission()
91     {
92 #ifdef WITH_SELINUX
93         int64_t begin = OHOS::GetTickCount();
94         auto callingSid = OHOS::IPCSkeleton::GetCallingSid();
95         auto ret = selinuxChecker_->ListServiceCheck(callingSid) == 0;
96         HILOG_SE_DEBUG(LOG_CORE, "ListServiceCheck callingSid:%{public}s,ret:%{public}s,spend:%{public}"
97             PRId64 "ms", callingSid.c_str(), ret == true ? "suc" : "fail", OHOS::GetTickCount() - begin);
98         return ret;
99 #else
100         return true; // if not support selinux, not check selinux permission
101 #endif
102     }
103 }
104 
105 using namespace OHOS::Security;
106 namespace OHOS {
107 namespace {
108 constexpr const char *EXT_TRANSACTION_PERMISSION = "ohos.permission.ACCESS_EXT_SYSTEM_ABILITY";
109 }
110 
SetAbilityFuncMap()111 void SystemAbilityManagerStub::SetAbilityFuncMap()
112 {
113     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_SYSTEM_ABILITY_TRANSACTION)] =
114         SystemAbilityManagerStub::LocalGetSystemAbility;
115     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::CHECK_SYSTEM_ABILITY_TRANSACTION)] =
116         SystemAbilityManagerStub::LocalCheckSystemAbility;
117     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::ADD_SYSTEM_ABILITY_TRANSACTION)] =
118         SystemAbilityManagerStub::LocalAddSystemAbility;
119     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::REMOVE_SYSTEM_ABILITY_TRANSACTION)] =
120         SystemAbilityManagerStub::LocalRemoveSystemAbility;
121     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::LIST_SYSTEM_ABILITY_TRANSACTION)] =
122         SystemAbilityManagerStub::LocalListSystemAbility;
123     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::SUBSCRIBE_SYSTEM_ABILITY_TRANSACTION)] =
124         SystemAbilityManagerStub::LocalSubsSystemAbility;
125     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::CHECK_REMOTE_SYSTEM_ABILITY_TRANSACTION)] =
126         SystemAbilityManagerStub::LocalCheckRemtSystemAbility;
127     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::ADD_ONDEMAND_SYSTEM_ABILITY_TRANSACTION)] =
128         SystemAbilityManagerStub::LocalAddOndemandSystemAbility;
129     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::CHECK_SYSTEM_ABILITY_IMMEDIATELY_TRANSACTION)] =
130         SystemAbilityManagerStub::LocalCheckSystemAbilityImme;
131     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::UNSUBSCRIBE_SYSTEM_ABILITY_TRANSACTION)] =
132         SystemAbilityManagerStub::LocalUnSubsSystemAbility;
133     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::LOAD_SYSTEM_ABILITY_TRANSACTION)] =
134         SystemAbilityManagerStub::LocalLoadSystemAbility;
135     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::LOAD_REMOTE_SYSTEM_ABILITY_TRANSACTION)] =
136         SystemAbilityManagerStub::LocalLoadRemoteSystemAbility;
137     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::UNLOAD_SYSTEM_ABILITY_TRANSACTION)] =
138         SystemAbilityManagerStub::LocalUnloadSystemAbility;
139     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::CANCEL_UNLOAD_SYSTEM_ABILITY_TRANSACTION)] =
140         SystemAbilityManagerStub::LocalCancelUnloadSystemAbility;
141 }
142 
SetProcessFuncMap()143 void SystemAbilityManagerStub::SetProcessFuncMap()
144 {
145     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::ADD_SYSTEM_PROCESS_TRANSACTION)] =
146         SystemAbilityManagerStub::LocalAddSystemProcess;
147     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_SYSTEM_PROCESS_INFO_TRANSACTION)] =
148         SystemAbilityManagerStub::LocalGetSystemProcessInfo;
149     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_RUNNING_SYSTEM_PROCESS_TRANSACTION)] =
150         SystemAbilityManagerStub::LocalGetRunningSystemProcess;
151     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::SUBSCRIBE_SYSTEM_PROCESS_TRANSACTION)] =
152         SystemAbilityManagerStub::LocalSubscribeSystemProcess;
153     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::UNSUBSCRIBE_SYSTEM_PROCESS_TRANSACTION)] =
154         SystemAbilityManagerStub::LocalUnSubscribeSystemProcess;
155 }
156 
SystemAbilityManagerStub()157 SystemAbilityManagerStub::SystemAbilityManagerStub()
158 {
159     SetAbilityFuncMap();
160     SetProcessFuncMap();
161     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_ONDEMAND_REASON_EXTRA_DATA_TRANSACTION)] =
162         SystemAbilityManagerStub::LocalGetOnDemandReasonExtraData;
163     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_ONDEAMND_POLICY_TRANSACTION)] =
164         SystemAbilityManagerStub::LocalGetOnDemandPolicy;
165     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::UPDATE_ONDEAMND_POLICY_TRANSACTION)] =
166         SystemAbilityManagerStub::LocalUpdateOnDemandPolicy;
167     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_ONDEMAND_SYSTEM_ABILITY_IDS_TRANSACTION)] =
168         SystemAbilityManagerStub::LocalGetOnDemandSystemAbilityIds;
169     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::SEND_STRATEGY_TRANASACTION)] =
170         SystemAbilityManagerStub::LocalSendStrategy;
171     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::UNLOAD_ALL_IDLE_SYSTEM_ABILITY_TRANSACTION)] =
172         SystemAbilityManagerStub::LocalUnloadAllIdleSystemAbility;
173     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_EXTENSION_SA_IDS_TRANSCATION)] =
174         SystemAbilityManagerStub::LocalGetExtensionSaIds;
175     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_EXTERNSION_SA_LIST_TRANSCATION)] =
176         SystemAbilityManagerStub::LocalGetExtensionRunningSaList;
177     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_SA_EXTENSION_INFO_TRANSCATION)] =
178         SystemAbilityManagerStub::LocalGetRunningSaExtensionInfoList;
179     memberFuncMap_[static_cast<uint32_t>(SamgrInterfaceCode::GET_COMMON_EVENT_EXTRA_ID_LIST_TRANSCATION)] =
180         SystemAbilityManagerStub::LocalGetCommonEventExtraDataIdlist;
181 }
182 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)183 int32_t SystemAbilityManagerStub::OnRemoteRequest(uint32_t code,
184     MessageParcel& data, MessageParcel& reply, MessageOption &option)
185 {
186     HILOGD("SAMStub::OnReceived, code = %{public}u, callerPid = %{public}d",
187         code, IPCSkeleton::GetCallingPid());
188     Samgr::MemoryGuard cacheGuard;
189     if (!EnforceInterceToken(data)) {
190         HILOGE("SAMStub::OnReceived, code = %{public}u, check interfaceToken failed", code);
191         return ERR_PERMISSION_DENIED;
192     }
193     auto itFunc = memberFuncMap_.find(code);
194     if (itFunc != memberFuncMap_.end()) {
195         return itFunc->second(this, data, reply);
196     }
197     HILOGW("SAMStub: default case, need check.");
198     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
199 }
200 
EnforceInterceToken(MessageParcel & data)201 bool SystemAbilityManagerStub::EnforceInterceToken(MessageParcel& data)
202 {
203     std::u16string interfaceToken = data.ReadInterfaceToken();
204     return interfaceToken == SAMANAGER_INTERFACE_TOKEN;
205 }
206 
ListSystemAbilityInner(MessageParcel & data,MessageParcel & reply)207 int32_t SystemAbilityManagerStub::ListSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
208 {
209     if (!CanRequest()) {
210         HILOGE("ListSystemAbilityInner PERMISSION DENIED!");
211         return ERR_PERMISSION_DENIED;
212     }
213 
214     if (!CheckListSAPermission()) {
215         HILOGE("ListSystemAbilityInner selinux permission denied! callSid:%{public}s",
216             OHOS::IPCSkeleton::GetCallingSid().c_str());
217         return ERR_PERMISSION_DENIED;
218     }
219 
220     int32_t dumpFlag = 0;
221     bool ret = data.ReadInt32(dumpFlag);
222     if (!ret) {
223         HILOGW("ListSystemAbilityInner read dumpflag failed!");
224         return ERR_FLATTEN_OBJECT;
225     }
226 
227     std::vector<std::u16string> saNameVector = ListSystemAbilities(dumpFlag);
228     if (saNameVector.empty()) {
229         HILOGI("List System Abilities list errors");
230         ret = reply.WriteInt32(ERR_INVALID_VALUE);
231     } else {
232         HILOGI("ListSystemAbilityInner list success");
233         ret = reply.WriteInt32(ERR_NONE);
234         if (ret) {
235             ret = reply.WriteString16Vector(saNameVector);
236         }
237     }
238 
239     if (!ret) {
240         HILOGW("ListSystemAbilityInner write reply failed.");
241         return ERR_FLATTEN_OBJECT;
242     }
243 
244     return ERR_NONE;
245 }
246 
SubsSystemAbilityInner(MessageParcel & data,MessageParcel & reply)247 int32_t SystemAbilityManagerStub::SubsSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
248 {
249     int32_t systemAbilityId = -1;
250     bool ret = data.ReadInt32(systemAbilityId);
251     if (!ret) {
252         return ERR_NULL_OBJECT;
253     }
254     if (!CheckInputSysAbilityId(systemAbilityId)) {
255         HILOGW("SubsSystemAbilityInner read SAId failed!");
256         return ERR_NULL_OBJECT;
257     }
258     sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
259     if (remoteObject == nullptr) {
260         HILOGW("SubsSystemAbilityInner read listener failed!");
261         return ERR_NULL_OBJECT;
262     }
263     sptr<ISystemAbilityStatusChange> listener = iface_cast<ISystemAbilityStatusChange>(remoteObject);
264     if (listener == nullptr) {
265         HILOGW("SubsSystemAbilityInner iface_cast failed!");
266         return ERR_NULL_OBJECT;
267     }
268     SamgrXCollie samgrXCollie("samgr--SubsSA_" + ToString(systemAbilityId));
269     int32_t result = SubscribeSystemAbility(systemAbilityId, listener);
270     HILOGD("SubsSystemAbilityInner result is %{public}d", result);
271     ret = reply.WriteInt32(result);
272     if (!ret) {
273         HILOGW("SubsSystemAbilityInner write reply failed.");
274         return ERR_FLATTEN_OBJECT;
275     }
276 
277     return result;
278 }
279 
UnSubsSystemAbilityInner(MessageParcel & data,MessageParcel & reply)280 int32_t SystemAbilityManagerStub::UnSubsSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
281 {
282     int32_t systemAbilityId = -1;
283     bool ret = data.ReadInt32(systemAbilityId);
284     if (!ret) {
285         return ERR_NULL_OBJECT;
286     }
287     if (!CheckInputSysAbilityId(systemAbilityId)) {
288         HILOGW("UnSubsSystemAbilityInner read SAId failed!");
289         return ERR_NULL_OBJECT;
290     }
291     sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
292     if (remoteObject == nullptr) {
293         HILOGW("UnSubscribeSystemAbility read listener failed!");
294         return ERR_NULL_OBJECT;
295     }
296     sptr<ISystemAbilityStatusChange> listener = iface_cast<ISystemAbilityStatusChange>(remoteObject);
297     if (listener == nullptr) {
298         HILOGW("UnSubscribeSystemAbility iface_cast failed!");
299         return ERR_NULL_OBJECT;
300     }
301     int32_t result = UnSubscribeSystemAbility(systemAbilityId, listener);
302     HILOGD("UnSubscribeSystemAbility result is %{public}d", result);
303     ret = reply.WriteInt32(result);
304     if (!ret) {
305         HILOGW("UnSubscribeSystemAbility write reply failed.");
306         return ERR_FLATTEN_OBJECT;
307     }
308 
309     return result;
310 }
311 
CheckRemtSystemAbilityInner(MessageParcel & data,MessageParcel & reply)312 int32_t SystemAbilityManagerStub::CheckRemtSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
313 {
314     if (!CanRequest()) {
315         HILOGE("CheckRemoteSystemAbilityInner PERMISSION DENIED!");
316         return ERR_PERMISSION_DENIED;
317     }
318     int32_t systemAbilityId = -1;
319     bool ret = data.ReadInt32(systemAbilityId);
320     if (!ret) {
321         return ERR_NULL_OBJECT;
322     }
323     if (!CheckInputSysAbilityId(systemAbilityId)) {
324         HILOGW("CheckRemtSystemAbilityInner read SAId failed!");
325         return ERR_NULL_OBJECT;
326     }
327 
328     if (!CheckGetRemoteSAPermission(systemAbilityId)) {
329         HILOGE("CheckRemtSystemAbilityInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
330             systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
331         return ERR_PERMISSION_DENIED;
332     }
333 
334     std::string deviceId;
335     ret = data.ReadString(deviceId);
336     if (!ret) {
337         HILOGW("CheckRemtSystemAbilityInner read deviceId failed!");
338         return ERR_FLATTEN_OBJECT;
339     }
340     std::string uuid = SamgrUtil::TransformDeviceId(deviceId, UUID, false);
341     sptr<IRemoteObject> remoteObject = GetSystemAbility(systemAbilityId, uuid);
342     if (remoteObject == nullptr) {
343         HILOGD("CheckRemtSystemAbilityInner SA:%{public}d GetSystemAbility failed.", systemAbilityId);
344         return ERR_NULL_OBJECT;
345     }
346     ret = reply.WriteRemoteObject(remoteObject);
347     if (!ret) {
348         HILOGE("CheckRemtSystemAbilityInner SA:%{public}d write reply failed.", systemAbilityId);
349         return ERR_FLATTEN_OBJECT;
350     }
351 
352     return ERR_NONE;
353 }
354 
AddOndemandSystemAbilityInner(MessageParcel & data,MessageParcel & reply)355 int32_t SystemAbilityManagerStub::AddOndemandSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
356 {
357     if (!CanRequest()) {
358         HILOGE("AddOndemandSystemAbilityInner PERMISSION DENIED!");
359         return ERR_PERMISSION_DENIED;
360     }
361     int32_t systemAbilityId = -1;
362     bool ret = data.ReadInt32(systemAbilityId);
363     if (!ret) {
364         return ERR_NULL_OBJECT;
365     }
366     if (!CheckInputSysAbilityId(systemAbilityId)) {
367         HILOGW("AddOndemandSystemAbilityInner read SAId failed!");
368         return ERR_NULL_OBJECT;
369     }
370 
371     if (!CheckAddOrRemovePermission(systemAbilityId)) {
372         HILOGE("AddOndemandSystemAbilityInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
373             systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
374         return ERR_PERMISSION_DENIED;
375     }
376 
377     std::u16string localManagerName = data.ReadString16();
378     if (localManagerName.empty()) {
379         HILOGW("AddOndemandSystemAbilityInner read localName failed!");
380         return ERR_NULL_OBJECT;
381     }
382 
383     int32_t result = AddOnDemandSystemAbilityInfo(systemAbilityId, localManagerName);
384     HILOGD("AddOndemandSystemAbilityInner result is %{public}d", result);
385     ret = reply.WriteInt32(result);
386     if (!ret) {
387         HILOGW("AddOndemandSystemAbilityInner write reply failed.");
388         return ERR_FLATTEN_OBJECT;
389     }
390 
391     return result;
392 }
393 
CheckSystemAbilityImmeInner(MessageParcel & data,MessageParcel & reply)394 int32_t SystemAbilityManagerStub::CheckSystemAbilityImmeInner(MessageParcel& data, MessageParcel& reply)
395 {
396     int64_t begin = OHOS::GetTickCount();
397     int32_t systemAbilityId = -1;
398     bool ret = data.ReadInt32(systemAbilityId);
399     if (!ret) {
400         return ERR_NULL_OBJECT;
401     }
402     if (!CheckInputSysAbilityId(systemAbilityId)) {
403         HILOGW("CheckSystemAbilityImmeInner read SAId failed!");
404         return ERR_NULL_OBJECT;
405     }
406 
407     if (!CheckGetSAPermission(systemAbilityId)) {
408         HILOGD("CheckSystemAbilityImmeInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
409             systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
410         return ERR_PERMISSION_DENIED;
411     }
412 
413     bool isExist = false;
414     ret = data.ReadBool(isExist);
415     if (!ret) {
416         HILOGW("CheckSystemAbilityImmeInner read isExist failed!");
417         return ERR_FLATTEN_OBJECT;
418     }
419     SamgrXCollie samgrXCollie("samgr--CheckSAImme_" + ToString(systemAbilityId));
420     sptr<IRemoteObject> remoteObject = CheckSystemAbility(systemAbilityId, isExist);
421     if (remoteObject == nullptr) {
422         HILOGD("CheckSystemAbilityImmeInner SA:%{public}d CheckSystemAbility failed.", systemAbilityId);
423         return ERR_NULL_OBJECT;
424     }
425     ret = reply.WriteRemoteObject(remoteObject);
426     if (!ret) {
427         HILOGE("CheckSystemAbilityImmeInner SA:%{public}d, callpid:%{public}d, write obj fail, spend %{public}"
428             PRId64 " ms", systemAbilityId, OHOS::IPCSkeleton::GetCallingPid(), OHOS::GetTickCount() - begin);
429         return ERR_FLATTEN_OBJECT;
430     }
431 
432     ret = reply.WriteBool(isExist);
433     if (!ret) {
434         HILOGW("CheckSystemAbilityImmeInner write reply failed.");
435         return ERR_FLATTEN_OBJECT;
436     }
437 
438     return ERR_NONE;
439 }
440 
UnmarshalingSaExtraProp(MessageParcel & data,SAExtraProp & extraProp)441 int32_t SystemAbilityManagerStub::UnmarshalingSaExtraProp(MessageParcel& data, SAExtraProp& extraProp)
442 {
443     bool isDistributed = false;
444     bool ret = data.ReadBool(isDistributed);
445     if (!ret) {
446         HILOGW("UnmarshalingSaExtraProp read isDistributed failed!");
447         return ERR_FLATTEN_OBJECT;
448     }
449 
450     int32_t dumpFlags = 0;
451     ret = data.ReadInt32(dumpFlags);
452     if (!ret || dumpFlags < 0) {
453         HILOGW("UnmarshalingSaExtraProp dumpFlags failed!");
454         return ERR_FLATTEN_OBJECT;
455     }
456     std::u16string capability = data.ReadString16();
457     std::u16string permission = data.ReadString16();
458     extraProp.isDistributed = isDistributed;
459     extraProp.dumpFlags = static_cast<uint32_t>(dumpFlags);
460     extraProp.capability = capability;
461     extraProp.permission = permission;
462     return ERR_OK;
463 }
464 
AddSystemAbilityInner(MessageParcel & data,MessageParcel & reply)465 int32_t SystemAbilityManagerStub::AddSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
466 {
467     if (!CanRequest()) {
468         KHILOGE("AddSystemAbilityInner PERMISSION DENIED!");
469         return ERR_PERMISSION_DENIED;
470     }
471     int32_t systemAbilityId = -1;
472     bool ret = data.ReadInt32(systemAbilityId);
473     if (!ret) {
474         return ERR_NULL_OBJECT;
475     }
476     if (!CheckInputSysAbilityId(systemAbilityId)) {
477         KHILOGW("AddSystemAbilityExtraInner read SAId failed!");
478         return ERR_NULL_OBJECT;
479     }
480 
481     if (!CheckAddOrRemovePermission(systemAbilityId)) {
482         KHILOGE("AddSystemAbilityInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
483             systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
484         return ERR_PERMISSION_DENIED;
485     }
486 
487     auto object = data.ReadRemoteObject();
488     if (object == nullptr) {
489         KHILOGW("AddSystemAbilityExtraInner readParcelable failed!");
490         return ERR_NULL_OBJECT;
491     }
492     SAExtraProp extraProp;
493     int32_t result = UnmarshalingSaExtraProp(data, extraProp);
494     if (result != ERR_OK) {
495         KHILOGW("AddSystemAbilityExtraInner UnmarshalingSaExtraProp failed!");
496         return result;
497     }
498     result = AddSystemAbility(systemAbilityId, object, extraProp);
499     ret = reply.WriteInt32(result);
500     if (!ret) {
501         KHILOGW("AddSystemAbilityExtraInner write reply failed.");
502         return ERR_FLATTEN_OBJECT;
503     }
504     return result;
505 }
506 
GetSystemAbilityInner(MessageParcel & data,MessageParcel & reply)507 int32_t SystemAbilityManagerStub::GetSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
508 {
509     int32_t systemAbilityId = -1;
510     bool ret = data.ReadInt32(systemAbilityId);
511     if (!ret) {
512         return ERR_NULL_OBJECT;
513     }
514     if (!CheckInputSysAbilityId(systemAbilityId)) {
515         HILOGW("GetSystemAbilityInner read SAId failed!");
516         return ERR_NULL_OBJECT;
517     }
518 
519     if (!CheckGetSAPermission(systemAbilityId)) {
520         HILOGE("GetSystemAbilityInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
521             systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
522         return ERR_PERMISSION_DENIED;
523     }
524     sptr<IRemoteObject> remoteObject = GetSystemAbility(systemAbilityId);
525     if (remoteObject == nullptr) {
526         HILOGD("GetSystemAbilityInner SA:%{public}d GetSystemAbility failed.", systemAbilityId);
527         return ERR_NULL_OBJECT;
528     }
529     ret = reply.WriteRemoteObject(remoteObject);
530     if (!ret) {
531         HILOGE("GetSystemAbilityInner SA:%{public}d write reply failed.", systemAbilityId);
532         return ERR_FLATTEN_OBJECT;
533     }
534     return ERR_NONE;
535 }
536 
CheckSystemAbilityInner(MessageParcel & data,MessageParcel & reply)537 int32_t SystemAbilityManagerStub::CheckSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
538 {
539     int32_t systemAbilityId = -1;
540     bool ret = data.ReadInt32(systemAbilityId);
541     if (!ret) {
542         return ERR_NULL_OBJECT;
543     }
544     if (!CheckInputSysAbilityId(systemAbilityId)) {
545         HILOGW("CheckSystemAbilityInner read SAId failed!");
546         return ERR_NULL_OBJECT;
547     }
548 
549     if (!CheckGetSAPermission(systemAbilityId)) {
550         HILOGD("CheckSystemAbilityInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
551             systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
552         return ERR_PERMISSION_DENIED;
553     }
554     sptr<IRemoteObject> remoteObject = CheckSystemAbility(systemAbilityId);
555     if (remoteObject == nullptr) {
556         HILOGD("CheckSystemAbilityInner SA:%{public}d CheckSystemAbility failed.", systemAbilityId);
557         return ERR_NULL_OBJECT;
558     }
559     ret = reply.WriteRemoteObject(remoteObject);
560     if (!ret) {
561         HILOGE("CheckSystemAbilityInner SA:%{public}d write reply failed.", systemAbilityId);
562         return ERR_FLATTEN_OBJECT;
563     }
564     return ERR_NONE;
565 }
566 
RemoveSystemAbilityInner(MessageParcel & data,MessageParcel & reply)567 int32_t SystemAbilityManagerStub::RemoveSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
568 {
569     if (!CanRequest()) {
570         HILOGE("RemoveSystemAbilityInner PERMISSION DENIED!");
571         return ERR_PERMISSION_DENIED;
572     }
573     int32_t systemAbilityId = -1;
574     bool ret = data.ReadInt32(systemAbilityId);
575     if (!ret) {
576         return ERR_NULL_OBJECT;
577     }
578     if (!CheckInputSysAbilityId(systemAbilityId)) {
579         HILOGW("RemoveSystemAbilityInner read SAId failed!");
580         return ERR_NULL_OBJECT;
581     }
582 
583     if (!CheckAddOrRemovePermission(systemAbilityId)) {
584         HILOGE("RemoveSystemAbilityInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
585             systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
586         return ERR_PERMISSION_DENIED;
587     }
588 
589     int32_t result = RemoveSystemAbility(systemAbilityId);
590     ret = reply.WriteInt32(result);
591     if (!ret) {
592         HILOGW("RemoveSystemAbilityInner write reply failed.");
593         return ERR_FLATTEN_OBJECT;
594     }
595     return result;
596 }
597 
598 
AddSystemProcessInner(MessageParcel & data,MessageParcel & reply)599 int32_t SystemAbilityManagerStub::AddSystemProcessInner(MessageParcel& data, MessageParcel& reply)
600 {
601     if (!CanRequest()) {
602         HILOGE("AddSystemProcessInner PERMISSION DENIED!");
603         return ERR_PERMISSION_DENIED;
604     }
605     std::u16string procName = data.ReadString16();
606     if (procName.empty()) {
607         HILOGW("AddSystemProcessInner read procName failed!");
608         return ERR_NULL_OBJECT;
609     }
610 
611     sptr<IRemoteObject> procObject = data.ReadRemoteObject();
612     if (procObject == nullptr) {
613         HILOGW("AddSystemProcessInner readParcelable failed!");
614         return ERR_NULL_OBJECT;
615     }
616 
617     int32_t result = AddSystemProcess(procName, procObject);
618     bool ret = reply.WriteInt32(result);
619     if (!ret) {
620         HILOGW("AddSystemProcessInner write reply failed.");
621         return ERR_FLATTEN_OBJECT;
622     }
623     return result;
624 }
625 
LoadSystemAbilityInner(MessageParcel & data,MessageParcel & reply)626 int32_t SystemAbilityManagerStub::LoadSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
627 {
628     int32_t systemAbilityId = -1;
629     bool ret = false;
630     sptr<ISystemAbilityLoadCallback> callback = nullptr;
631     {
632         SamgrXCollie samgrXCollie("samgrStub--loadSa_readData");
633         ret = data.ReadInt32(systemAbilityId);
634         if (!ret) {
635             HILOGW("LoadSystemAbilityInner read SAId failed!");
636             return ERR_INVALID_VALUE;
637         }
638         std::string loadSystemAbilityTag = ToString(systemAbilityId) + "_LoadSystemAbility";
639         HITRACE_METER_NAME(HITRACE_TAG_SAMGR, loadSystemAbilityTag);
640         if (!CheckInputSysAbilityId(systemAbilityId)) {
641             HILOGW("LoadSystemAbilityInner check SAId failed!");
642             return ERR_INVALID_VALUE;
643         }
644 
645         if (!CheckGetSAPermission(systemAbilityId)) {
646             HILOGE("LoadSystemAbilityInner selinux permission denied!SA:%{public}d,callSid:%{public}s",
647                 systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
648             return ERR_PERMISSION_DENIED;
649         }
650 
651         sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
652         if (remoteObject == nullptr) {
653             HILOGW("LoadSystemAbilityInner read callback failed!");
654             return ERR_INVALID_VALUE;
655         }
656         callback = iface_cast<ISystemAbilityLoadCallback>(remoteObject);
657         if (callback == nullptr) {
658             HILOGW("LoadSystemAbilityInner iface_cast failed!");
659             return ERR_INVALID_VALUE;
660         }
661     }
662 
663     int32_t result = LoadSystemAbility(systemAbilityId, callback);
664     if (result != ERR_OK) {
665         ReportSamgrSaLoadFail(systemAbilityId, IPCSkeleton::GetCallingPid(), IPCSkeleton::GetCallingUid(),
666             "interface load err:" + ToString(result));
667         HILOGE("loadSaInner fail ret:%{public}d", result);
668     }
669     HILOGD("LoadSystemAbilityInner result is %{public}d", result);
670     {
671         SamgrXCollie samgrXCollie("samgrStub--loadSa_writeResult_" + ToString(systemAbilityId));
672         ret = reply.WriteInt32(result);
673     }
674     if (!ret) {
675         HILOGW("LoadSystemAbilityInner write reply failed.");
676         return ERR_FLATTEN_OBJECT;
677     }
678     return result;
679 }
680 
LoadRemoteSystemAbilityInner(MessageParcel & data,MessageParcel & reply)681 int32_t SystemAbilityManagerStub::LoadRemoteSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
682 {
683     int32_t systemAbilityId = -1;
684     bool ret = false;
685     std::string deviceId = "";
686     sptr<IRemoteObject> remoteObject = nullptr;
687     sptr<ISystemAbilityLoadCallback> callback = nullptr;
688     {
689         SamgrXCollie samgrXCollie("samgrStub--loadRmtSa_readData");
690         ret = data.ReadInt32(systemAbilityId);
691         if (!ret) {
692             HILOGW("LoadRemoteSystemAbilityInner read SAId invalid");
693             return ERR_INVALID_VALUE;
694         }
695         if (!CheckInputSysAbilityId(systemAbilityId)) {
696             HILOGW("LoadRemoteSystemAbilityInner check SAId invalid");
697             return ERR_INVALID_VALUE;
698         }
699 
700         if (!CheckGetRemoteSAPermission(systemAbilityId)) {
701             HILOGE("LoadRemoteSystemAbilityInner selinux permission denied! SA:%{public}d,callSid:%{public}s",
702                 systemAbilityId, OHOS::IPCSkeleton::GetCallingSid().c_str());
703             return ERR_PERMISSION_DENIED;
704         }
705 
706         deviceId = data.ReadString();
707         if (deviceId.empty()) {
708             HILOGW("LoadRemoteSystemAbilityInner read deviceId failed");
709             return ERR_INVALID_VALUE;
710         }
711         remoteObject = data.ReadRemoteObject();
712         if (remoteObject == nullptr) {
713             HILOGW("LoadRemoteSystemAbilityInner read callback failed!");
714             return ERR_INVALID_VALUE;
715         }
716         callback = iface_cast<ISystemAbilityLoadCallback>(remoteObject);
717         if (callback == nullptr) {
718             HILOGW("LoadRemoteSystemAbilityInner iface_cast failed!");
719             return ERR_INVALID_VALUE;
720         }
721     }
722 
723     int32_t result = LoadSystemAbility(systemAbilityId, deviceId, callback);
724     HILOGD("LoadRemoteSystemAbilityInner result is %{public}d", result);
725     {
726         SamgrXCollie samgrXCollie("samgrStub--loadRmtSa_writeResult_" + ToString(systemAbilityId));
727         ret = reply.WriteInt32(result);
728     }
729     if (!ret) {
730         HILOGW("LoadRemoteSystemAbilityInner write reply failed.");
731         return ERR_FLATTEN_OBJECT;
732     }
733     return result;
734 }
735 
UnloadSystemAbilityInner(MessageParcel & data,MessageParcel & reply)736 int32_t SystemAbilityManagerStub::UnloadSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
737 {
738     int32_t systemAbilityId = -1;
739     bool ret = false;
740     {
741         SamgrXCollie samgrXCollie("samgrStub--unloadSa_readData");
742         ret = data.ReadInt32(systemAbilityId);
743         if (!ret) {
744             HILOGW("UnloadSystemAbilityInner read SAId invalid");
745             return ERR_INVALID_VALUE;
746         }
747         if (!CheckInputSysAbilityId(systemAbilityId)) {
748             HILOGW("UnloadSystemAbilityInner check SAId invalid");
749             return ERR_INVALID_VALUE;
750         }
751     }
752 
753     int32_t result = UnloadSystemAbility(systemAbilityId);
754     if (result != ERR_OK) {
755         ReportSaUnLoadFail(systemAbilityId, IPCSkeleton::GetCallingPid(), IPCSkeleton::GetCallingUid(),
756             "interface unload err:" + ToString(result));
757         HILOGE("unloadSa fail ret:%{public}d", result);
758     }
759     HILOGD("UnloadSystemAbilityInner result is %{public}d", result);
760     {
761         SamgrXCollie samgrXCollie("samgrStub--unloadSa_writeResult_" + ToString(systemAbilityId));
762         ret = reply.WriteInt32(result);
763     }
764     if (!ret) {
765         HILOGW("UnloadSystemAbilityInner write reply failed.");
766         return ERR_FLATTEN_OBJECT;
767     }
768     return result;
769 }
770 
UnloadAllIdleSystemAbilityInner(MessageParcel & data,MessageParcel & reply)771 int32_t SystemAbilityManagerStub::UnloadAllIdleSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
772 {
773     int32_t result = UnloadAllIdleSystemAbility();
774     HILOGI("UnloadAllIdleSystemAbilityInner result is %{public}d", result);
775     return result;
776 }
777 
GetSystemProcessInfoInner(MessageParcel & data,MessageParcel & reply)778 int32_t SystemAbilityManagerStub::GetSystemProcessInfoInner(MessageParcel& data, MessageParcel& reply)
779 {
780     HILOGI("GetSystemProcessInfoInner called");
781     if (!CanRequest()) {
782         HILOGE("GetSystemProcessInfoInner PERMISSION DENIED!");
783         return ERR_PERMISSION_DENIED;
784     }
785     int32_t systemAbilityId = -1;
786     bool ret = data.ReadInt32(systemAbilityId);
787     if (!ret) {
788         return ERR_NULL_OBJECT;
789     }
790     if (!CheckInputSysAbilityId(systemAbilityId)) {
791         HILOGW("GetSystemProcessInfoInner read SAId failed!");
792         return ERR_NULL_OBJECT;
793     }
794     SystemProcessInfo processInfo;
795     int32_t result = GetSystemProcessInfo(systemAbilityId, processInfo);
796     ret = reply.WriteInt32(result);
797     if (!ret) {
798         HILOGW("GetSystemProcessInfoInner write reply failed.");
799         return ERR_FLATTEN_OBJECT;
800     }
801     if (result != ERR_OK) {
802         return ERR_OK;
803     }
804 
805     ret = reply.WriteString(processInfo.processName);
806     if (!ret) {
807         HILOGW("GetSystemProcessInfoInner write procName failed.");
808         return ERR_FLATTEN_OBJECT;
809     }
810     ret = reply.WriteInt32(processInfo.pid);
811     if (!ret) {
812         HILOGW("GetSystemProcessInfoInner write pid failed.");
813         return ERR_FLATTEN_OBJECT;
814     }
815     ret = reply.WriteInt32(processInfo.uid);
816     if (!ret) {
817         HILOGW("GetSystemProcessInfoInner write uid failed.");
818             return ERR_FLATTEN_OBJECT;
819     }
820     return ERR_OK;
821 }
822 
GetRunningSystemProcessInner(MessageParcel & data,MessageParcel & reply)823 int32_t SystemAbilityManagerStub::GetRunningSystemProcessInner(MessageParcel& data, MessageParcel& reply)
824 {
825     HILOGI("GetRunningSystemProcessInner called");
826     if (!CanRequest()) {
827         HILOGE("GetRunningSystemProcessInner PERMISSION DENIED!");
828         return ERR_PERMISSION_DENIED;
829     }
830     std::list<SystemProcessInfo> systemProcessInfos;
831     int32_t result = GetRunningSystemProcess(systemProcessInfos);
832     bool ret = reply.WriteInt32(result);
833     if (!ret) {
834         HILOGW("GetRunningSystemProcessInner write reply failed.");
835         return ERR_FLATTEN_OBJECT;
836     }
837     if (result != ERR_OK) {
838         return ERR_OK;
839     }
840 
841     size_t size = systemProcessInfos.size();
842     ret = reply.WriteInt32(size);
843     if (!ret) {
844         HILOGW("GetRunningSystemProcessInner write ProcInfos size failed.");
845         return ERR_FLATTEN_OBJECT;
846     }
847     for (auto& systemProcessInfo : systemProcessInfos) {
848         ret = reply.WriteString(systemProcessInfo.processName);
849         if (!ret) {
850             HILOGW("GetRunningSystemProcessInner write procName failed.");
851             return ERR_FLATTEN_OBJECT;
852         }
853         ret = reply.WriteInt32(systemProcessInfo.pid);
854         if (!ret) {
855             HILOGW("GetRunningSystemProcessInner write pid failed.");
856             return ERR_FLATTEN_OBJECT;
857         }
858         ret = reply.WriteInt32(systemProcessInfo.uid);
859         if (!ret) {
860             HILOGW("GetRunningSystemProcessInner write uid failed.");
861             return ERR_FLATTEN_OBJECT;
862         }
863     }
864     return ERR_OK;
865 }
866 
SubscribeSystemProcessInner(MessageParcel & data,MessageParcel & reply)867 int32_t SystemAbilityManagerStub::SubscribeSystemProcessInner(MessageParcel& data, MessageParcel& reply)
868 {
869     if (!CanRequest()) {
870         HILOGE("SubscribeSystemProcessInner PERMISSION DENIED!");
871         return ERR_PERMISSION_DENIED;
872     }
873     sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
874     if (remoteObject == nullptr) {
875         HILOGW("SubscribeSystemProcessInner read listener failed!");
876         return ERR_NULL_OBJECT;
877     }
878     sptr<ISystemProcessStatusChange> listener = iface_cast<ISystemProcessStatusChange>(remoteObject);
879     if (listener == nullptr) {
880         HILOGW("SubscribeSystemProcessInner iface_cast failed!");
881         return ERR_NULL_OBJECT;
882     }
883     int32_t result = SubscribeSystemProcess(listener);
884     HILOGD("SubscribeSystemProcess result is %{public}d", result);
885     bool ret = reply.WriteInt32(result);
886     if (!ret) {
887         HILOGW("SubscribeSystemProcessInner write reply failed.");
888         return ERR_FLATTEN_OBJECT;
889     }
890     return result;
891 }
892 
UnSubscribeSystemProcessInner(MessageParcel & data,MessageParcel & reply)893 int32_t SystemAbilityManagerStub::UnSubscribeSystemProcessInner(MessageParcel& data, MessageParcel& reply)
894 {
895     if (!CanRequest()) {
896         HILOGE("UnSubscribeSystemProcessInner PERMISSION DENIED!");
897         return ERR_PERMISSION_DENIED;
898     }
899     sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
900     if (remoteObject == nullptr) {
901         HILOGW("UnSubscribeSystemProcessInner read listener failed!");
902         return ERR_NULL_OBJECT;
903     }
904     sptr<ISystemProcessStatusChange> listener = iface_cast<ISystemProcessStatusChange>(remoteObject);
905     if (listener == nullptr) {
906         HILOGW("UnSubscribeSystemProcessInner iface_cast failed!");
907         return ERR_NULL_OBJECT;
908     }
909     int32_t result = UnSubscribeSystemProcess(listener);
910     HILOGD("UnSubscribeSystemProcessInner result is %{public}d", result);
911     bool ret = reply.WriteInt32(result);
912     if (!ret) {
913         HILOGW("UnSubscribeSystemProcessInner write reply failed.");
914         return ERR_FLATTEN_OBJECT;
915     }
916     return result;
917 }
918 
CancelUnloadSystemAbilityInner(MessageParcel & data,MessageParcel & reply)919 int32_t SystemAbilityManagerStub::CancelUnloadSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
920 {
921     int32_t systemAbilityId = -1;
922     bool ret = data.ReadInt32(systemAbilityId);
923     if (!ret) {
924         return ERR_INVALID_VALUE;
925     }
926     if (!CheckInputSysAbilityId(systemAbilityId)) {
927         HILOGW("CancelUnloadSystemAbilityInner SAId invalid");
928         return ERR_INVALID_VALUE;
929     }
930     int32_t result = CancelUnloadSystemAbility(systemAbilityId);
931     HILOGD("CancelUnloadSystemAbilityInner result is %{public}d", result);
932     ret = reply.WriteInt32(result);
933     if (!ret) {
934         HILOGW("CancelUnloadSystemAbilityInner write reply failed.");
935         return ERR_FLATTEN_OBJECT;
936     }
937     return result;
938 }
939 
GetOnDemandReasonExtraDataInner(MessageParcel & data,MessageParcel & reply)940 int32_t SystemAbilityManagerStub::GetOnDemandReasonExtraDataInner(MessageParcel& data, MessageParcel& reply)
941 {
942     if (!CanRequest()) {
943         HILOGE("GetOnDemandReasonExtraData PERMISSION DENIED!");
944         return ERR_PERMISSION_DENIED;
945     }
946     int64_t extraDataId = -1;
947     if (!data.ReadInt64(extraDataId)) {
948         HILOGW("GetOnDemandReasonExtraData read extraDataId failed.");
949         return ERR_FLATTEN_OBJECT;
950     }
951     MessageParcel extraDataParcel;
952     int32_t result = GetOnDemandReasonExtraData(extraDataId, extraDataParcel);
953     HILOGD("GetOnDemandReasonExtraData result is %{public}d", result);
954     if (!reply.WriteInt32(result)) {
955         HILOGW("GetOnDemandReasonExtraData write reply failed.");
956         return ERR_FLATTEN_OBJECT;
957     }
958     sptr<OnDemandReasonExtraData> extraData;
959     extraData = extraDataParcel.ReadParcelable<OnDemandReasonExtraData>();
960     if (extraData == nullptr) {
961         HILOGW("GetOnDemandReasonExtraData read extraData failed.");
962         return ERR_FLATTEN_OBJECT;
963     }
964     if (!reply.WriteParcelable(extraData)) {
965         HILOGW("GetOnDemandReasonExtraData write extraData failed.");
966         return ERR_FLATTEN_OBJECT;
967     }
968     return ERR_OK;
969 }
970 
GetOnDemandPolicyInner(MessageParcel & data,MessageParcel & reply)971 int32_t SystemAbilityManagerStub::GetOnDemandPolicyInner(MessageParcel& data, MessageParcel& reply)
972 {
973     if (!CanRequest()) {
974         HILOGE("GetOnDemandPolicyInner PERMISSION DENIED!");
975         return ERR_PERMISSION_DENIED;
976     }
977     int32_t systemAbilityId = -1;
978     if (!data.ReadInt32(systemAbilityId)) {
979         HILOGW("GetOnDemandPolicyInner read saId failed.");
980         return ERR_FLATTEN_OBJECT;
981     }
982     int32_t type = 0;
983     if (!data.ReadInt32(type)) {
984         HILOGW("GetOnDemandPolicyInner read type failed.");
985         return ERR_FLATTEN_OBJECT;
986     }
987     OnDemandPolicyType typeEnum = static_cast<OnDemandPolicyType>(type);
988     std::vector<SystemAbilityOnDemandEvent> abilityOnDemandEvents;
989     int32_t result = GetOnDemandPolicy(systemAbilityId, typeEnum, abilityOnDemandEvents);
990     if (!reply.WriteInt32(result)) {
991         HILOGW("GetOnDemandPolicyInner write result failed.");
992         return ERR_FLATTEN_OBJECT;
993     }
994     if (!OnDemandEventToParcel::WriteOnDemandEventsToParcel(abilityOnDemandEvents, reply)) {
995         HILOGW("GetOnDemandPolicyInner write on demand event failed.");
996         return ERR_FLATTEN_OBJECT;
997     }
998     return ERR_OK;
999 }
1000 
UpdateOnDemandPolicyInner(MessageParcel & data,MessageParcel & reply)1001 int32_t SystemAbilityManagerStub::UpdateOnDemandPolicyInner(MessageParcel& data, MessageParcel& reply)
1002 {
1003     if (!CanRequest()) {
1004         HILOGE("UpdateOnDemandPolicyInner PERMISSION DENIED!");
1005         return ERR_PERMISSION_DENIED;
1006     }
1007     int32_t systemAbilityId = -1;
1008     if (!data.ReadInt32(systemAbilityId)) {
1009         HILOGW("UpdateOnDemandPolicyInner read saId failed.");
1010         return ERR_FLATTEN_OBJECT;
1011     }
1012     int32_t type = 0;
1013     if (!data.ReadInt32(type)) {
1014         HILOGW("GetOnDemandPolicyInner read type failed.");
1015         return ERR_FLATTEN_OBJECT;
1016     }
1017     OnDemandPolicyType typeEnum = static_cast<OnDemandPolicyType>(type);
1018     std::vector<SystemAbilityOnDemandEvent> abilityOnDemandEvents;
1019     if (!OnDemandEventToParcel::ReadOnDemandEventsFromParcel(abilityOnDemandEvents, data)) {
1020         HILOGW("UpdateOnDemandPolicyInner read on demand event failed.");
1021         return ERR_FLATTEN_OBJECT;
1022     }
1023     int32_t result = UpdateOnDemandPolicy(systemAbilityId, typeEnum, abilityOnDemandEvents);
1024     if (!reply.WriteInt32(result)) {
1025         HILOGW("UpdateOnDemandPolicyInner write result failed.");
1026         return ERR_FLATTEN_OBJECT;
1027     }
1028     return ERR_OK;
1029 }
1030 
SendStrategyInner(MessageParcel & data,MessageParcel & reply)1031 int32_t SystemAbilityManagerStub::SendStrategyInner(MessageParcel& data, MessageParcel& reply)
1032 {
1033     if (!CanRequest()) {
1034         HILOGE("SendStrategy PERMISSION DENIED!");
1035         return ERR_PERMISSION_DENIED;
1036     }
1037     int32_t type = 0;
1038     if (!data.ReadInt32(type)) {
1039         HILOGW("SendStrategy read type failed.");
1040         return ERR_FLATTEN_OBJECT;
1041     }
1042     std::vector<int32_t> systemAbilityIds;
1043     if (!data.ReadInt32Vector(&systemAbilityIds)) {
1044         HILOGW("SendStrategy read saId failed.");
1045         return ERR_FLATTEN_OBJECT;
1046     }
1047     int32_t level = -1;
1048     if (!data.ReadInt32(level)) {
1049         HILOGW("SendStrategy read level failed.");
1050         return ERR_FLATTEN_OBJECT;
1051     }
1052     std::string action;
1053     if (!data.ReadString(action)) {
1054         HILOGW("SendStrategy read action failed!");
1055         return ERR_FLATTEN_OBJECT;
1056     }
1057     int32_t result = SendStrategy(type, systemAbilityIds, level, action);
1058     if (!reply.WriteInt32(result)) {
1059         HILOGW("SendStrategy write result failed.");
1060         return ERR_FLATTEN_OBJECT;
1061     }
1062     return ERR_OK;
1063 }
1064 
GetOnDemandSystemAbilityIdsInner(MessageParcel & data,MessageParcel & reply)1065 int32_t SystemAbilityManagerStub::GetOnDemandSystemAbilityIdsInner(MessageParcel& data, MessageParcel& reply)
1066 {
1067     std::vector<int32_t> systemAbilityIds;
1068     int32_t result = GetOnDemandSystemAbilityIds(systemAbilityIds);
1069     if (result != ERR_OK) {
1070         HILOGW("GetOnDemandSystemAbilityIds failed, ret:%{public}d", result);
1071         return result;
1072     }
1073     if (!reply.WriteInt32(result)) {
1074         HILOGE("GetOnDemandSystemAbilityIdsInner write result failed.");
1075         return ERR_FLATTEN_OBJECT;
1076     }
1077     if (!reply.WriteInt32Vector(systemAbilityIds)) {
1078         HILOGE("GetOnDemandSystemAbilityIdsInner write result failed.");
1079         return ERR_FLATTEN_OBJECT;
1080     }
1081     return ERR_OK;
1082 }
1083 
CanRequest()1084 bool SystemAbilityManagerStub::CanRequest()
1085 {
1086     auto tid = IPCSkeleton::GetCallingTokenID();
1087     AccessToken::ATokenTypeEnum tokenType = AccessToken::AccessTokenKit::GetTokenTypeFlag(tid);
1088     HILOGD("CanRequest callingTkid:%{private}u, tokenType:%{public}d",
1089         tid, tokenType);
1090     return (tokenType == AccessToken::ATokenTypeEnum::TOKEN_NATIVE);
1091 }
1092 
CheckPermission(const std::string & permission)1093 bool SystemAbilityManagerStub::CheckPermission(const std::string& permission)
1094 {
1095     uint32_t accessToken = IPCSkeleton::GetCallingTokenID();
1096     int32_t ret = Security::AccessToken::AccessTokenKit::VerifyAccessToken(accessToken, permission);
1097     return (ret == Security::AccessToken::PermissionState::PERMISSION_GRANTED);
1098 }
1099 
GetExtensionSaIdsInner(MessageParcel & data,MessageParcel & reply)1100 int32_t SystemAbilityManagerStub::GetExtensionSaIdsInner(MessageParcel& data, MessageParcel& reply)
1101 {
1102     if (!CanRequest()) {
1103         HILOGE("%{public}s  PERMISSION DENIED!", __func__);
1104         return ERR_PERMISSION_DENIED;
1105     }
1106     std::string extension;
1107     if (!data.ReadString(extension)) {
1108         HILOGW("%{public}s read extension failed!", __func__);
1109         return ERR_FLATTEN_OBJECT;
1110     }
1111 
1112     std::vector<int32_t> saIds;
1113     int32_t result = GetExtensionSaIds(extension, saIds);
1114     if (result != ERR_OK) {
1115         HILOGW("GetExtensionSaIds failed, ret:%{public}d", result);
1116         return result;
1117     }
1118     if (!reply.WriteInt32(result)) {
1119         HILOGW("%{public}s write reply failed.", __func__);
1120         return ERR_FLATTEN_OBJECT;
1121     }
1122     if (!reply.WriteInt32Vector(saIds)) {
1123         HILOGW("%{public}s write saids reply failed.", __func__);
1124         return ERR_FLATTEN_OBJECT;
1125     }
1126 
1127     return ERR_NONE;
1128 }
1129 
GetExtensionRunningSaListInner(MessageParcel & data,MessageParcel & reply)1130 int32_t SystemAbilityManagerStub::GetExtensionRunningSaListInner(MessageParcel& data, MessageParcel& reply)
1131 {
1132     if (!CanRequest()) {
1133         HILOGE("%{public}s PERMISSION DENIED!", __func__);
1134         return ERR_PERMISSION_DENIED;
1135     }
1136     std::string extension;
1137     if (!data.ReadString(extension)) {
1138         HILOGW("%{public}s read extension failed!", __func__);
1139         return ERR_FLATTEN_OBJECT;
1140     }
1141 
1142     std::vector<sptr<IRemoteObject>> saList;
1143     int32_t result = GetExtensionRunningSaList(extension, saList);
1144     if (result != ERR_OK) {
1145         HILOGW("GetExtensionRunningSaList failed, ret:%{public}d", result);
1146         return result;
1147     }
1148     if (!reply.WriteInt32(result)) {
1149         HILOGW("%{public}s write reply failed.", __func__);
1150         return ERR_FLATTEN_OBJECT;
1151     }
1152     if (!reply.WriteInt32(saList.size())) {
1153         HILOGW("%{public}s write saHandle size failed.", __func__);
1154         return ERR_FLATTEN_OBJECT;
1155     }
1156     for (auto& remoteObject : saList) {
1157         if (!reply.WriteRemoteObject(remoteObject)) {
1158             HILOGW("%{public}s write remote obj failed.", __func__);
1159             return ERR_FLATTEN_OBJECT;
1160         }
1161     }
1162 
1163     return ERR_NONE;
1164 }
1165 
GetRunningSaExtensionInfoListInner(MessageParcel & data,MessageParcel & reply)1166 int32_t SystemAbilityManagerStub::GetRunningSaExtensionInfoListInner(MessageParcel& data, MessageParcel& reply)
1167 {
1168     if (!CheckPermission(EXT_TRANSACTION_PERMISSION)) {
1169         HILOGE("get SaExtInfoList CheckPermission fail!");
1170         return ERR_PERMISSION_DENIED;
1171     }
1172     std::string extension;
1173     if (!data.ReadString(extension)) {
1174         HILOGE("get SaExtInfoList read extension failed!");
1175         return ERR_FLATTEN_OBJECT;
1176     }
1177 
1178     std::vector<SaExtensionInfo> infoList;
1179     int32_t result = GetRunningSaExtensionInfoList(extension, infoList);
1180     if (!reply.WriteInt32(result)) {
1181         HILOGE("get SaExtInfoList write ret failed.");
1182         return ERR_FLATTEN_OBJECT;
1183     }
1184     if (result != ERR_OK) {
1185         HILOGE("get SaExtInfoList failed,ret:%{public}d", result);
1186         return result;
1187     }
1188     if (!reply.WriteInt32(infoList.size())) {
1189         HILOGE("get SaExtInfoList write size failed.");
1190         return ERR_FLATTEN_OBJECT;
1191     }
1192     for (auto& tmp : infoList) {
1193         if (!reply.WriteInt32(tmp.saId)) {
1194             HILOGE("get SaExtInfoList write said failed.");
1195             return ERR_FLATTEN_OBJECT;
1196         }
1197         if (!reply.WriteRemoteObject(tmp.processObj)) {
1198             HILOGE("get SaExtInfoList write obj failed.");
1199             return ERR_FLATTEN_OBJECT;
1200         }
1201     }
1202     return ERR_NONE;
1203 }
1204 
GetCommonEventExtraDataIdlistInner(MessageParcel & data,MessageParcel & reply)1205 int32_t SystemAbilityManagerStub::GetCommonEventExtraDataIdlistInner(MessageParcel& data, MessageParcel& reply)
1206 {
1207     if (!CanRequest()) {
1208         HILOGE("getExtraIdList PERMISSION DENIED!");
1209         return ERR_PERMISSION_DENIED;
1210     }
1211     int32_t saId = -1;
1212     if (!data.ReadInt32(saId)) {
1213         HILOGE("getExtraIdList read said fail!");
1214         return ERR_NULL_OBJECT;
1215     }
1216     if (!CheckInputSysAbilityId(saId)) {
1217         HILOGW("getExtraIdList check SAId failed!");
1218         return ERR_NULL_OBJECT;
1219     }
1220     std::string eventName;
1221     if (!data.ReadString(eventName)) {
1222         HILOGW("getExtraIdList read eventName failed!");
1223         return ERR_FLATTEN_OBJECT;
1224     }
1225 
1226     std::vector<int64_t> extraDataIdList;
1227     int32_t result = GetCommonEventExtraDataIdlist(saId, extraDataIdList, eventName);
1228     if (!reply.WriteInt32(result)) {
1229         HILOGW("getExtraIdList write result failed.");
1230         return ERR_FLATTEN_OBJECT;
1231     }
1232     if (result != ERR_OK) {
1233         HILOGE("getExtraIdList failed,ret:%{public}d", result);
1234         return result;
1235     }
1236     if (!reply.WriteInt64Vector(extraDataIdList)) {
1237         HILOGW("getExtraIdList write idlist failed.");
1238         return ERR_FLATTEN_OBJECT;
1239     }
1240     return ERR_NONE;
1241 }
1242 } // namespace OHOS
1243