1 /*
2 * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "local_ability_manager_stub.h"
17
18 #include <cstdint>
19 #include <utility>
20 #include <cinttypes>
21
22 #include "errors.h"
23 #include "hilog/log_cpp.h"
24 #include "if_local_ability_manager.h"
25 #include "ipc_types.h"
26 #include "message_option.h"
27 #include "message_parcel.h"
28 #include "parse_util.h"
29 #include "safwk_log.h"
30 #include "datetime_ex.h"
31 #include "system_ability_definition.h"
32 #include "ipc_skeleton.h"
33 #include "accesstoken_kit.h"
34
35 using namespace OHOS::HiviewDFX;
36
37 namespace OHOS {
38 namespace {
39 const std::string PERMISSION_EXT_TRANSACTION = "ohos.permission.ACCESS_EXT_SYSTEM_ABILITY";
40 const std::string PERMISSION_MANAGE = "ohos.permission.MANAGE_SYSTEM_ABILITY";
41 const std::string PERMISSION_SVC = "ohos.permission.CONTROL_SVC_CMD";
42 }
43
LocalAbilityManagerStub()44 LocalAbilityManagerStub::LocalAbilityManagerStub()
45 {
46 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::START_ABILITY_TRANSACTION)] =
47 LocalAbilityManagerStub::LocalStartAbility;
48 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::STOP_ABILITY_TRANSACTION)] =
49 LocalAbilityManagerStub::LocalStopAbility;
50 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::ACTIVE_ABILITY_TRANSACTION)] =
51 LocalAbilityManagerStub::LocalActiveAbility;
52 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::IDLE_ABILITY_TRANSACTION)] =
53 LocalAbilityManagerStub::LocalIdleAbility;
54 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::SEND_STRATEGY_TO_SA_TRANSACTION)] =
55 LocalAbilityManagerStub::LocalSendStrategyToSA;
56 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::IPC_STAT_CMD_TRANSACTION)] =
57 LocalAbilityManagerStub::LocalIpcStatCmdProc;
58 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::FFRT_DUMPER_TRANSACTION)] =
59 LocalAbilityManagerStub::LocalFfrtDumperProc;
60 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::SYSTEM_ABILITY_EXT_TRANSACTION)] =
61 LocalAbilityManagerStub::LocalSystemAbilityExtProc;
62 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::FFRT_STAT_CMD_TRANSACTION)] =
63 LocalAbilityManagerStub::LocalFfrtStatCmdProc;
64 memberFuncMap_[static_cast<uint32_t>(SafwkInterfaceCode::SERVICE_CONTROL_CMD_TRANSACTION)] =
65 LocalAbilityManagerStub::LocalServiceControlCmd;
66 }
67
CheckPermission(uint32_t code)68 bool LocalAbilityManagerStub::CheckPermission(uint32_t code)
69 {
70 uint32_t accessToken = IPCSkeleton::GetCallingTokenID();
71 std::string permissionToCheck;
72
73 if (code == static_cast<uint32_t>(SafwkInterfaceCode::SYSTEM_ABILITY_EXT_TRANSACTION)) {
74 permissionToCheck = PERMISSION_EXT_TRANSACTION;
75 } else if (code == static_cast<uint32_t>(SafwkInterfaceCode::SERVICE_CONTROL_CMD_TRANSACTION)) {
76 permissionToCheck = PERMISSION_SVC;
77 } else {
78 permissionToCheck = PERMISSION_MANAGE;
79 }
80
81 int32_t ret = Security::AccessToken::AccessTokenKit::VerifyAccessToken(accessToken, permissionToCheck);
82 return ret == static_cast<int32_t>(Security::AccessToken::PermissionState::PERMISSION_GRANTED);
83 }
84
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)85 int32_t LocalAbilityManagerStub::OnRemoteRequest(uint32_t code,
86 MessageParcel& data, MessageParcel& reply, MessageOption& option)
87 {
88 HILOGD(TAG, "code:%{public}u, flags:%{public}d", code, option.GetFlags());
89 if (!EnforceInterceToken(data)) {
90 HILOGW(TAG, "check interface token failed!");
91 return ERR_PERMISSION_DENIED;
92 }
93
94 if (CheckPermission(code) == false) {
95 HILOGW(TAG, "check permission failed! code:%{public}u, callingPid:%{public}d, callingTokenId:%{public}u",
96 code, IPCSkeleton::GetCallingPid(), IPCSkeleton::GetCallingTokenID());
97 return ERR_PERMISSION_DENIED;
98 }
99 HILOGD(TAG, "check permission success!");
100
101 auto iter = memberFuncMap_.find(code);
102 if (iter != memberFuncMap_.end()) {
103 return iter->second(this, data, reply);
104 }
105 HILOGW(TAG, "unknown request code!");
106 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
107 }
108
StartAbilityInner(MessageParcel & data,MessageParcel & reply)109 int32_t LocalAbilityManagerStub::StartAbilityInner(MessageParcel& data, MessageParcel& reply)
110 {
111 int32_t saId = -1;
112 bool ret = data.ReadInt32(saId);
113 if (!ret) {
114 HILOGW(TAG, "read saId failed!");
115 return ERR_NULL_OBJECT;
116 }
117 if (!CheckInputSysAbilityId(saId)) {
118 HILOGW(TAG, "check SA:%{public}d id failed!", saId);
119 return ERR_NULL_OBJECT;
120 }
121 int64_t begin = GetTickCount();
122 std::string eventStr = data.ReadString();
123 if (eventStr.empty()) {
124 HILOGW(TAG, "LocalAbilityManagerStub::StartAbilityInner read eventStr failed!");
125 return ERR_NULL_OBJECT;
126 }
127 bool result = StartAbility(saId, eventStr);
128 LOGI("StartSaInner %{public}s to start SA:%{public}d,eventLen:%{public}zu,spend:%{public}" PRId64 "ms",
129 result ? "suc" : "fail", saId, eventStr.length(), (GetTickCount() - begin));
130 return ERR_NONE;
131 }
132
StopAbilityInner(MessageParcel & data,MessageParcel & reply)133 int32_t LocalAbilityManagerStub::StopAbilityInner(MessageParcel& data, MessageParcel& reply)
134 {
135 int32_t saId = -1;
136 bool ret = data.ReadInt32(saId);
137 if (!ret) {
138 return ERR_NULL_OBJECT;
139 }
140 if (!CheckInputSysAbilityId(saId)) {
141 HILOGW(TAG, "read saId failed!");
142 return ERR_NULL_OBJECT;
143 }
144 int64_t begin = GetTickCount();
145 std::string eventStr = data.ReadString();
146 if (eventStr.empty()) {
147 HILOGW(TAG, "StopAbilityInner read eventStr failed!");
148 return ERR_NULL_OBJECT;
149 }
150 bool result = StopAbility(saId, eventStr);
151 LOGI("StopSaInner %{public}s to stop SA:%{public}d,eventLen:%{public}zu,spend:%{public}" PRId64 "ms",
152 result ? "suc" : "fail", saId, eventStr.length(), (GetTickCount() - begin));
153 return ERR_NONE;
154 }
155
ActiveAbilityInner(MessageParcel & data,MessageParcel & reply)156 int32_t LocalAbilityManagerStub::ActiveAbilityInner(MessageParcel& data, MessageParcel& reply)
157 {
158 int32_t saId = -1;
159 bool ret = data.ReadInt32(saId);
160 if (!ret) {
161 return ERR_NULL_OBJECT;
162 }
163 if (!CheckInputSysAbilityId(saId)) {
164 HILOGW(TAG, "read saId failed!");
165 return ERR_NULL_OBJECT;
166 }
167 int64_t begin = GetTickCount();
168 nlohmann::json activeReason = ParseUtil::StringToJsonObj(data.ReadString());
169 bool result = ActiveAbility(saId, activeReason);
170 if (!reply.WriteBool(result)) {
171 HILOGW(TAG, "ActiveAbilityInner Write result failed!");
172 return ERR_NULL_OBJECT;
173 }
174 LOGI("ActiveSaInner %{public}s to Active SA:%{public}d,spend:%{public}" PRId64 "ms",
175 result ? "suc" : "fail", saId, (GetTickCount() - begin));
176 return ERR_NONE;
177 }
178
IdleAbilityInner(MessageParcel & data,MessageParcel & reply)179 int32_t LocalAbilityManagerStub::IdleAbilityInner(MessageParcel& data, MessageParcel& reply)
180 {
181 int32_t saId = -1;
182 bool ret = data.ReadInt32(saId);
183 if (!ret) {
184 return ERR_NULL_OBJECT;
185 }
186 if (!CheckInputSysAbilityId(saId)) {
187 HILOGW(TAG, "read saId failed!");
188 return ERR_NULL_OBJECT;
189 }
190 int64_t begin = GetTickCount();
191 nlohmann::json idleReason = ParseUtil::StringToJsonObj(data.ReadString());
192 int32_t delayTime = 0;
193 bool result = IdleAbility(saId, idleReason, delayTime);
194 if (!reply.WriteBool(result)) {
195 HILOGW(TAG, "ActiveAbilityInner Write result failed!");
196 return ERR_NULL_OBJECT;
197 }
198 if (!reply.WriteInt32(delayTime)) {
199 HILOGW(TAG, "ActiveAbilityInner Write delayTime failed!");
200 return ERR_NULL_OBJECT;
201 }
202 LOGI("IdleSaInner %{public}s to Idle SA:%{public}d,delayTime:%{public}d,spend:%{public}" PRId64 "ms",
203 result ? "suc" : "fail", saId, delayTime, (GetTickCount() - begin));
204 return ERR_NONE;
205 }
206
SendStrategyToSAInner(MessageParcel & data,MessageParcel & reply)207 int32_t LocalAbilityManagerStub::SendStrategyToSAInner(MessageParcel& data, MessageParcel& reply)
208 {
209 int32_t type = -1;
210 bool ret = data.ReadInt32(type);
211 if (!ret) {
212 return ERR_NULL_OBJECT;
213 }
214 int32_t saId = -1;
215 ret = data.ReadInt32(saId);
216 if (!ret) {
217 return ERR_NULL_OBJECT;
218 }
219 if (!CheckInputSysAbilityId(saId)) {
220 HILOGW(TAG, "read saId failed!");
221 return ERR_NULL_OBJECT;
222 }
223 int32_t level = -1;
224 ret = data.ReadInt32(level);
225 if (!ret) {
226 return ERR_NULL_OBJECT;
227 }
228 std::string aciton;
229 ret = data.ReadString(aciton);
230 if (!ret) {
231 return ERR_NULL_OBJECT;
232 }
233 bool result = SendStrategyToSA(type, saId, level, aciton);
234 if (!result) {
235 HILOGE(TAG, "SendStrategyToSA:%{public}d called failed", saId);
236 return ERR_NULL_OBJECT;
237 }
238 return ERR_NONE;
239 }
240
IpcStatCmdProcInner(MessageParcel & data,MessageParcel & reply)241 int32_t LocalAbilityManagerStub::IpcStatCmdProcInner(MessageParcel& data, MessageParcel& reply)
242 {
243 int32_t fd = data.ReadFileDescriptor();
244 if (fd < 0) {
245 return ERR_NULL_OBJECT;
246 }
247 int cmd = -1;
248 bool ret = data.ReadInt32(cmd);
249 if (!ret) {
250 ::close(fd);
251 return ERR_NULL_OBJECT;
252 }
253 bool result = IpcStatCmdProc(fd, cmd);
254 if (!reply.WriteBool(result)) {
255 HILOGW(TAG, "IpcStatCmdProc Write result failed!");
256 ::close(fd);
257 return ERR_NULL_OBJECT;
258 }
259 ::close(fd);
260 HILOGD(TAG, "IpcStatCmdProc called %{public}s ", result ? "success" : "failed");
261 return ERR_NONE;
262 }
263
FfrtStatCmdProcInner(MessageParcel & data,MessageParcel & reply)264 int32_t LocalAbilityManagerStub::FfrtStatCmdProcInner(MessageParcel& data, MessageParcel& reply)
265 {
266 int32_t fd = data.ReadFileDescriptor();
267 if (fd < 0) {
268 return ERR_NULL_OBJECT;
269 }
270 int cmd = -1;
271 bool ret = data.ReadInt32(cmd);
272 if (!ret) {
273 ::close(fd);
274 return ERR_NULL_OBJECT;
275 }
276 bool result = FfrtStatCmdProc(fd, cmd);
277 if (!reply.WriteBool(result)) {
278 HILOGW(TAG, "FfrtStatCmdProc Write result failed!");
279 ::close(fd);
280 return ERR_NULL_OBJECT;
281 }
282 ::close(fd);
283 HILOGD(TAG, "FfrtStatCmdProc called %{public}s ", result ? "success" : "failed");
284 return ERR_NONE;
285 }
286
FfrtDumperProcInner(MessageParcel & data,MessageParcel & reply)287 int32_t LocalAbilityManagerStub::FfrtDumperProcInner(MessageParcel& data, MessageParcel& reply)
288 {
289 std::string ffrtDumperInfo;
290 bool result = FfrtDumperProc(ffrtDumperInfo);
291 HILOGI(TAG, "safwk ffrt dumper result %{public}s", result ? "succeed" : "failed");
292 if (!reply.WriteString(ffrtDumperInfo)) {
293 HILOGW(TAG, "FfrtDumperProc write ffrtDumperInfo failed!");
294 return ERR_NULL_OBJECT;
295 }
296 HILOGD(TAG, "FfrtDumperProc called %{public}s ", result? "success" : "failed");
297 return ERR_NONE;
298 }
299
SystemAbilityExtProcInner(MessageParcel & data,MessageParcel & reply)300 int32_t LocalAbilityManagerStub::SystemAbilityExtProcInner(MessageParcel& data, MessageParcel& reply)
301 {
302 int32_t saId = -1;
303 bool ret = data.ReadInt32(saId);
304 if (!ret) {
305 return INVALID_DATA;
306 }
307 if (!CheckInputSysAbilityId(saId)) {
308 HILOGW(TAG, "read saId failed!");
309 return INVALID_DATA;
310 }
311 std::string extension = data.ReadString();
312 if (extension.empty()) {
313 HILOGW(TAG, "LocalAbilityManagerStub::SystemAbilityExtProcInner read extension failed!");
314 return INVALID_DATA;
315 }
316
317 SystemAbilityExtensionPara callback;
318 callback.data_ = &data;
319 callback.reply_ = &reply;
320
321 int32_t result = SystemAbilityExtProc(extension, saId, &callback, false);
322 if (result != ERR_NONE) {
323 HILOGW(TAG, "SystemAbilityExtProc fail!");
324 return result;
325 }
326
327 HILOGD(TAG, "SystemAbilityExtProc success ");
328 return ERR_NONE;
329 }
330
CheckInputSysAbilityId(int32_t systemAbilityId)331 bool LocalAbilityManagerStub::CheckInputSysAbilityId(int32_t systemAbilityId)
332 {
333 return (systemAbilityId >= FIRST_SYS_ABILITY_ID) && (systemAbilityId <= LAST_SYS_ABILITY_ID);
334 }
335
EnforceInterceToken(MessageParcel & data)336 bool LocalAbilityManagerStub::EnforceInterceToken(MessageParcel& data)
337 {
338 std::u16string interfaceToken = data.ReadInterfaceToken();
339 return interfaceToken == LOCAL_ABILITY_MANAGER_INTERFACE_TOKEN;
340 }
341
ServiceControlCmdInner(MessageParcel & data,MessageParcel & reply)342 int32_t LocalAbilityManagerStub::ServiceControlCmdInner(MessageParcel& data, MessageParcel& reply)
343 {
344 int32_t systemAbilityId = -1;
345 bool ret = data.ReadInt32(systemAbilityId);
346 if (!ret) {
347 HILOGE(TAG, "ServiceControlCmdInner read systemAbilityId failed");
348 return INVALID_DATA;
349 }
350 if (!CheckInputSysAbilityId(systemAbilityId)) {
351 HILOGE(TAG, "ServiceControlCmdInner check systemAbilityId failed");
352 return INVALID_DATA;
353 }
354
355 int32_t fd = data.ReadFileDescriptor();
356 if (fd < 0) {
357 HILOGE(TAG, "ServiceControlCmdInner get invalid fd");
358 return INVALID_DATA;
359 }
360
361 std::vector<std::u16string> args;
362 ret = data.ReadString16Vector(&args);
363 if (!ret) {
364 HILOGE(TAG, "ServiceControlCmdInner read args failed");
365 ::close(fd);
366 return INVALID_DATA;
367 }
368
369 int32_t result = ServiceControlCmd(fd, systemAbilityId, args);
370 if (result != ERR_NONE) {
371 HILOGE(TAG, "ServiceControlCmdInner failed, result: %{public}d", result);
372 }
373 ::close(fd);
374 return result;
375 }
376 }
377