1 /*
2  * Copyright (c) 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 "start_ability_utils.h"
17 
18 #include "ability_record.h"
19 #include "ability_util.h"
20 #include "app_utils.h"
21 #include "global_constant.h"
22 #include "hitrace_meter.h"
23 #include "startup_util.h"
24 
25 namespace OHOS {
26 namespace AAFwk {
27 namespace {
28 constexpr int32_t ERMS_ISALLOW_RESULTCODE = 10;
29 constexpr const char* PARAM_RESV_ANCO_CALLER_UID = "ohos.anco.param.callerUid";
30 constexpr const char* PARAM_RESV_ANCO_CALLER_BUNDLENAME = "ohos.anco.param.callerBundleName";
31 }
32 thread_local std::shared_ptr<StartAbilityInfo> StartAbilityUtils::startAbilityInfo;
33 thread_local std::shared_ptr<StartAbilityInfo> StartAbilityUtils::callerAbilityInfo;
34 thread_local bool StartAbilityUtils::skipCrowTest = false;
35 thread_local bool StartAbilityUtils::skipStartOther = false;
36 thread_local bool StartAbilityUtils::skipErms = false;
37 thread_local int32_t StartAbilityUtils::ermsResultCode = ERMS_ISALLOW_RESULTCODE;
38 thread_local bool StartAbilityUtils::isWantWithAppCloneIndex = false;
39 thread_local bool StartAbilityUtils::ermsSupportBackToCallerFlag = false;
40 
GetAppIndex(const Want &want, sptr<IRemoteObject> callerToken, int32_t &appIndex)41 bool StartAbilityUtils::GetAppIndex(const Want &want, sptr<IRemoteObject> callerToken, int32_t &appIndex)
42 {
43     auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
44     if (abilityRecord && abilityRecord->GetAppIndex() > AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX &&
45         abilityRecord->GetApplicationInfo().bundleName == want.GetElement().GetBundleName()) {
46         appIndex = abilityRecord->GetAppIndex();
47         return true;
48     }
49     TAG_LOGI(AAFwkTag::ABILITYMGR, "appCloneIndex:%{public}d", want.GetIntParam(Want::PARAM_APP_CLONE_INDEX_KEY, 0));
50     return AbilityRuntime::StartupUtil::GetAppIndex(want, appIndex);
51 }
52 
GetApplicationInfo(const std::string &bundleName, int32_t userId, AppExecFwk::ApplicationInfo &appInfo)53 bool StartAbilityUtils::GetApplicationInfo(const std::string &bundleName, int32_t userId,
54     AppExecFwk::ApplicationInfo &appInfo)
55 {
56     if (StartAbilityUtils::startAbilityInfo &&
57         StartAbilityUtils::startAbilityInfo->GetAppBundleName() == bundleName) {
58         appInfo = StartAbilityUtils::startAbilityInfo->abilityInfo.applicationInfo;
59         return true;
60     }
61     if (bundleName.empty()) {
62         return false;
63     }
64     auto bms = AbilityUtil::GetBundleManagerHelper();
65     CHECK_POINTER_AND_RETURN(bms, false);
66     bool result = IN_PROCESS_CALL(
67         bms->GetApplicationInfo(bundleName, AppExecFwk::ApplicationFlag::GET_BASIC_APPLICATION_INFO,
68             userId, appInfo)
69     );
70     if (!result) {
71         TAG_LOGW(AAFwkTag::ABILITYMGR, "failed: %{public}s", bundleName.c_str());
72         return false;
73     }
74     return true;
75 }
76 
GetCallerAbilityInfo(const sptr<IRemoteObject> &callerToken, AppExecFwk::AbilityInfo &abilityInfo)77 bool StartAbilityUtils::GetCallerAbilityInfo(const sptr<IRemoteObject> &callerToken,
78     AppExecFwk::AbilityInfo &abilityInfo)
79 {
80     if (StartAbilityUtils::callerAbilityInfo) {
81         abilityInfo = StartAbilityUtils::callerAbilityInfo->abilityInfo;
82     } else {
83         if (callerToken == nullptr) {
84             return false;
85         }
86         auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
87         if (abilityRecord == nullptr) {
88             return false;
89         }
90         abilityInfo = abilityRecord->GetAbilityInfo();
91     }
92     return true;
93 }
94 
CheckAppProvisionMode(const std::string& bundleName, int32_t userId)95 int32_t StartAbilityUtils::CheckAppProvisionMode(const std::string& bundleName, int32_t userId)
96 {
97     AppExecFwk::ApplicationInfo appInfo;
98     if (!GetApplicationInfo(bundleName, userId, appInfo)) {
99         TAG_LOGE(AAFwkTag::ABILITYMGR, "Get application info failed: %{public}s", bundleName.c_str());
100         return ERR_INVALID_VALUE;
101     }
102     if (appInfo.appProvisionType != AppExecFwk::Constants::APP_PROVISION_TYPE_DEBUG) {
103         return ERR_NOT_IN_APP_PROVISION_MODE;
104     }
105     return ERR_OK;
106 }
107 
CheckAppProvisionMode(const Want& want, int32_t userId)108 int32_t StartAbilityUtils::CheckAppProvisionMode(const Want& want, int32_t userId)
109 {
110     auto abilityInfo = StartAbilityUtils::startAbilityInfo;
111     if (!abilityInfo || abilityInfo->GetAppBundleName() != want.GetElement().GetBundleName()) {
112         int32_t appIndex = 0;
113         if (!AbilityRuntime::StartupUtil::GetAppIndex(want, appIndex)) {
114             TAG_LOGE(AAFwkTag::ABILITYMGR, "invalid app clone index");
115             return ERR_APP_CLONE_INDEX_INVALID;
116         }
117         abilityInfo = StartAbilityInfo::CreateStartAbilityInfo(want, userId, appIndex);
118     }
119     CHECK_POINTER_AND_RETURN(abilityInfo, GET_ABILITY_SERVICE_FAILED);
120     if (abilityInfo->status != ERR_OK) {
121         TAG_LOGE(AAFwkTag::ABILITYMGR, "unexpected abilityInfo status: %{public}d", abilityInfo->status);
122         return abilityInfo->status;
123     }
124     if ((abilityInfo->abilityInfo).applicationInfo.appProvisionType !=
125         AppExecFwk::Constants::APP_PROVISION_TYPE_DEBUG) {
126         TAG_LOGE(AAFwkTag::ABILITYMGR, "window options invalid");
127         return ERR_NOT_IN_APP_PROVISION_MODE;
128     }
129     return ERR_OK;
130 }
131 
GetCloneAppIndexes(const std::string &bundleName, int32_t userId)132 std::vector<int32_t> StartAbilityUtils::GetCloneAppIndexes(const std::string &bundleName, int32_t userId)
133 {
134     std::vector<int32_t> appIndexes;
135     auto bms = AbilityUtil::GetBundleManagerHelper();
136     CHECK_POINTER_AND_RETURN(bms, appIndexes);
137     IN_PROCESS_CALL_WITHOUT_RET(bms->GetCloneAppIndexes(bundleName, appIndexes, userId));
138     return appIndexes;
139 }
140 
StartAbilityInfoWrap(const Want &want, int32_t validUserId, int32_t appIndex, const sptr<IRemoteObject> &callerToken, bool isExtension)141 StartAbilityInfoWrap::StartAbilityInfoWrap(const Want &want, int32_t validUserId, int32_t appIndex,
142     const sptr<IRemoteObject> &callerToken, bool isExtension)
143 {
144     if (StartAbilityUtils::startAbilityInfo != nullptr) {
145         TAG_LOGW(AAFwkTag::ABILITYMGR, "startAbilityInfo created");
146     }
147     Want localWant = want;
148     if (!StartAbilityUtils::IsCallFromAncoShellOrBroker(callerToken)) {
149         TAG_LOGD(AAFwkTag::ABILITYMGR, "not call from anco or broker.");
150         localWant.RemoveParam(PARAM_RESV_ANCO_CALLER_UID);
151         localWant.RemoveParam(PARAM_RESV_ANCO_CALLER_BUNDLENAME);
152         localWant.RemoveParam(Want::PARAM_RESV_CALLER_TOKEN);
153         localWant.RemoveParam(Want::PARAM_RESV_CALLER_UID);
154         localWant.RemoveParam(Want::PARAM_RESV_CALLER_BUNDLE_NAME);
155         localWant.SetParam(Want::PARAM_RESV_CALLER_TOKEN, static_cast<int32_t>(IPCSkeleton::GetCallingTokenID()));
156         localWant.SetParam(Want::PARAM_RESV_CALLER_UID, IPCSkeleton::GetCallingUid());
157     }
158     if (isExtension) {
159         StartAbilityUtils::startAbilityInfo = StartAbilityInfo::CreateStartExtensionInfo(localWant,
160             validUserId, appIndex);
161     } else {
162         StartAbilityUtils::startAbilityInfo = StartAbilityInfo::CreateStartAbilityInfo(localWant,
163             validUserId, appIndex);
164     }
165     if (StartAbilityUtils::startAbilityInfo != nullptr &&
166         StartAbilityUtils::startAbilityInfo->abilityInfo.type == AppExecFwk::AbilityType::EXTENSION) {
167         StartAbilityUtils::skipCrowTest = true;
168         StartAbilityUtils::skipStartOther = true;
169     }
170 
171     if (StartAbilityUtils::callerAbilityInfo != nullptr) {
172         TAG_LOGW(AAFwkTag::ABILITYMGR, "callerAbilityInfo created");
173     }
174     StartAbilityUtils::callerAbilityInfo = StartAbilityInfo::CreateCallerAbilityInfo(callerToken);
175 
176     StartAbilityUtils::ermsResultCode = ERMS_ISALLOW_RESULTCODE;
177     StartAbilityUtils::isWantWithAppCloneIndex = false;
178     if (want.HasParameter(AAFwk::Want::PARAM_APP_CLONE_INDEX_KEY) && appIndex >= 0 &&
179         appIndex < AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
180         StartAbilityUtils::isWantWithAppCloneIndex = true;
181     }
182 }
183 
~StartAbilityInfoWrap()184 StartAbilityInfoWrap::~StartAbilityInfoWrap()
185 {
186     StartAbilityUtils::startAbilityInfo.reset();
187     StartAbilityUtils::callerAbilityInfo.reset();
188     StartAbilityUtils::skipCrowTest = false;
189     StartAbilityUtils::skipStartOther = false;
190     StartAbilityUtils::skipErms = false;
191     StartAbilityUtils::ermsResultCode = ERMS_ISALLOW_RESULTCODE;
192     StartAbilityUtils::isWantWithAppCloneIndex = false;
193 }
194 
CreateStartAbilityInfo(const Want &want, int32_t userId, int32_t appIndex)195 std::shared_ptr<StartAbilityInfo> StartAbilityInfo::CreateStartAbilityInfo(const Want &want, int32_t userId,
196     int32_t appIndex)
197 {
198     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
199     auto bms = AbilityUtil::GetBundleManagerHelper();
200     CHECK_POINTER_AND_RETURN(bms, nullptr);
201     auto abilityInfoFlag = static_cast<uint32_t>(AbilityRuntime::StartupUtil::BuildAbilityInfoFlag()) |
202         static_cast<uint32_t>(AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_SKILL);
203     auto request = std::make_shared<StartAbilityInfo>();
204     if (appIndex > 0 && appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
205         IN_PROCESS_CALL_WITHOUT_RET(bms->QueryCloneAbilityInfo(want.GetElement(), abilityInfoFlag, appIndex,
206             request->abilityInfo, userId));
207         if (request->abilityInfo.name.empty() || request->abilityInfo.bundleName.empty()) {
208             FindExtensionInfo(want, abilityInfoFlag, userId, appIndex, request);
209         }
210         return request;
211     }
212     if (appIndex == 0) {
213         IN_PROCESS_CALL_WITHOUT_RET(bms->QueryAbilityInfo(want, abilityInfoFlag, userId, request->abilityInfo));
214     } else {
215         IN_PROCESS_CALL_WITHOUT_RET(bms->GetSandboxAbilityInfo(want, appIndex,
216             abilityInfoFlag, userId, request->abilityInfo));
217     }
218     if (request->abilityInfo.name.empty() || request->abilityInfo.bundleName.empty()) {
219         // try to find extension
220         std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
221         if (appIndex == 0) {
222             IN_PROCESS_CALL_WITHOUT_RET(bms->QueryExtensionAbilityInfos(want, abilityInfoFlag,
223                 userId, extensionInfos));
224         } else {
225             IN_PROCESS_CALL_WITHOUT_RET(bms->GetSandboxExtAbilityInfos(want, appIndex,
226                 abilityInfoFlag, userId, extensionInfos));
227         }
228         if (extensionInfos.size() <= 0) {
229             TAG_LOGE(AAFwkTag::ABILITYMGR, "extensionInfo empty");
230             request->status = RESOLVE_ABILITY_ERR;
231             return request;
232         }
233 
234         AppExecFwk::ExtensionAbilityInfo extensionInfo = extensionInfos.front();
235         if (extensionInfo.bundleName.empty() || extensionInfo.name.empty()) {
236             TAG_LOGE(AAFwkTag::ABILITYMGR, "extensionInfo empty.");
237             request->status = RESOLVE_ABILITY_ERR;
238             return request;
239         }
240         request->extensionProcessMode = extensionInfo.extensionProcessMode;
241         // For compatibility translates to AbilityInfo
242         AbilityRuntime::StartupUtil::InitAbilityInfoFromExtension(extensionInfo, request->abilityInfo);
243     }
244     return request;
245 }
246 
CreateStartExtensionInfo(const Want &want, int32_t userId, int32_t appIndex)247 std::shared_ptr<StartAbilityInfo> StartAbilityInfo::CreateStartExtensionInfo(const Want &want, int32_t userId,
248     int32_t appIndex)
249 {
250     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
251     auto bms = AbilityUtil::GetBundleManagerHelper();
252     CHECK_POINTER_AND_RETURN(bms, nullptr);
253     auto abilityInfoFlag = static_cast<uint32_t>(AbilityRuntime::StartupUtil::BuildAbilityInfoFlag()) |
254         static_cast<uint32_t>(AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_SKILL);
255     auto abilityInfo = std::make_shared<StartAbilityInfo>();
256     if (appIndex > 0 && appIndex <= AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
257         FindExtensionInfo(want, abilityInfoFlag, userId, appIndex, abilityInfo);
258         return abilityInfo;
259     }
260 
261     std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
262     if (appIndex == 0) {
263         IN_PROCESS_CALL_WITHOUT_RET(bms->QueryExtensionAbilityInfos(want, abilityInfoFlag, userId, extensionInfos));
264     } else {
265         IN_PROCESS_CALL_WITHOUT_RET(bms->GetSandboxExtAbilityInfos(want, appIndex,
266             abilityInfoFlag, userId, extensionInfos));
267     }
268     if (extensionInfos.size() <= 0) {
269         TAG_LOGE(AAFwkTag::ABILITYMGR, "extensionInfo empty");
270         abilityInfo->status = RESOLVE_ABILITY_ERR;
271         return abilityInfo;
272     }
273 
274     AppExecFwk::ExtensionAbilityInfo extensionInfo = extensionInfos.front();
275     if (extensionInfo.bundleName.empty() || extensionInfo.name.empty()) {
276         TAG_LOGE(AAFwkTag::ABILITYMGR, "extensionInfo empty");
277         abilityInfo->status = RESOLVE_ABILITY_ERR;
278         return abilityInfo;
279     }
280     abilityInfo->extensionProcessMode = extensionInfo.extensionProcessMode;
281     // For compatibility translates to AbilityInfo
282     AbilityRuntime::StartupUtil::InitAbilityInfoFromExtension(extensionInfo, abilityInfo->abilityInfo);
283 
284     return abilityInfo;
285 }
286 
FindExtensionInfo(const Want &want, int32_t flags, int32_t userId, int32_t appIndex, std::shared_ptr<StartAbilityInfo> abilityInfo)287 void StartAbilityInfo::FindExtensionInfo(const Want &want, int32_t flags, int32_t userId,
288     int32_t appIndex, std::shared_ptr<StartAbilityInfo> abilityInfo)
289 {
290     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
291     CHECK_POINTER_LOG(abilityInfo, "abilityInfo is invalid.");
292     auto bms = AbilityUtil::GetBundleManagerHelper();
293     CHECK_POINTER_LOG(bms, "bms is invalid.");
294     AppExecFwk::ExtensionAbilityInfo extensionInfo;
295     IN_PROCESS_CALL_WITHOUT_RET(bms->QueryCloneExtensionAbilityInfoWithAppIndex(want.GetElement(),
296         flags, appIndex, extensionInfo, userId));
297     if (extensionInfo.bundleName.empty() || extensionInfo.name.empty()) {
298         TAG_LOGE(AAFwkTag::ABILITYMGR, "extensionInfo empty");
299         abilityInfo->status = RESOLVE_ABILITY_ERR;
300         return;
301     }
302     if (AbilityRuntime::StartupUtil::IsSupportAppClone(extensionInfo.type)) {
303         abilityInfo->extensionProcessMode = extensionInfo.extensionProcessMode;
304         // For compatibility translates to AbilityInfo
305         AbilityRuntime::StartupUtil::InitAbilityInfoFromExtension(extensionInfo, abilityInfo->abilityInfo);
306     } else {
307         abilityInfo->status = ERR_APP_CLONE_INDEX_INVALID;
308     }
309 }
310 
CreateCallerAbilityInfo(const sptr<IRemoteObject> &callerToken)311 std::shared_ptr<StartAbilityInfo> StartAbilityInfo::CreateCallerAbilityInfo(const sptr<IRemoteObject> &callerToken)
312 {
313     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
314     if (callerToken == nullptr) {
315         TAG_LOGD(AAFwkTag::ABILITYMGR, "not call from context.");
316         return nullptr;
317     }
318     auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
319     if (abilityRecord == nullptr) {
320         TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityRecord empty");
321         return nullptr;
322     }
323     auto request = std::make_shared<StartAbilityInfo>();
324     request->abilityInfo = abilityRecord->GetAbilityInfo();
325     return request;
326 }
327 
IsCallFromAncoShellOrBroker(const sptr<IRemoteObject> &callerToken)328 bool StartAbilityUtils::IsCallFromAncoShellOrBroker(const sptr<IRemoteObject> &callerToken)
329 {
330     auto callingUid = IPCSkeleton::GetCallingUid();
331     if (callingUid == AppUtils::GetInstance().GetCollaboratorBrokerUID()) {
332         return true;
333     }
334     AppExecFwk::AbilityInfo callerAbilityInfo;
335     if (GetCallerAbilityInfo(callerToken, callerAbilityInfo)) {
336         return callerAbilityInfo.bundleName == AppUtils::GetInstance().GetBrokerDelegateBundleName();
337     }
338     return false;
339 }
340 }
341 }